1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 99, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
26 Emacs separates the task of updating the display from code
27 modifying global state, e.g. buffer text. This way functions
28 operating on buffers don't also have to be concerned with updating
31 Updating the display is triggered by the Lisp interpreter when it
32 decides it's time to do it. This is done either automatically for
33 you as part of the interpreter's command loop or as the result of
34 calling Lisp functions like `sit-for'. The C function `redisplay'
35 in xdisp.c is the only entry into the inner redisplay code. (Or,
36 let's say almost---see the description of direct update
39 The following diagram shows how redisplay code is invoked. As you
40 can see, Lisp calls redisplay and vice versa. Under window systems
41 like X, some portions of the redisplay code are also called
42 asynchronously during mouse movement or expose events. It is very
43 important that these code parts do NOT use the C library (malloc,
44 free) because many C libraries under Unix are not reentrant. They
45 may also NOT call functions of the Lisp interpreter which could
46 change the interpreter's state. If you don't follow these rules,
47 you will encounter bugs which are very hard to explain.
49 (Direct functions, see below)
50 direct_output_for_insert,
51 direct_forward_char (dispnew.c)
52 +---------------------------------+
55 +--------------+ redisplay +----------------+
56 | Lisp machine |---------------->| Redisplay code |<--+
57 +--------------+ (xdisp.c) +----------------+ |
59 +----------------------------------+ |
60 Don't use this path when called |
63 expose_window (asynchronous) |
65 X expose events -----+
67 What does redisplay? Obviously, it has to figure out somehow what
68 has been changed since the last time the display has been updated,
69 and to make these changes visible. Preferably it would do that in
70 a moderately intelligent way, i.e. fast.
72 Changes in buffer text can be deduced from window and buffer
73 structures, and from some global variables like `beg_unchanged' and
74 `end_unchanged'. The contents of the display are additionally
75 recorded in a `glyph matrix', a two-dimensional matrix of glyph
76 structures. Each row in such a matrix corresponds to a line on the
77 display, and each glyph in a row corresponds to a column displaying
78 a character, an image, or what else. This matrix is called the
79 `current glyph matrix' or `current matrix' in redisplay
82 For buffer parts that have been changed since the last update, a
83 second glyph matrix is constructed, the so called `desired glyph
84 matrix' or short `desired matrix'. Current and desired matrix are
85 then compared to find a cheap way to update the display, e.g. by
86 reusing part of the display by scrolling lines.
91 You will find a lot of redisplay optimizations when you start
92 looking at the innards of redisplay. The overall goal of all these
93 optimizations is to make redisplay fast because it is done
96 Two optimizations are not found in xdisp.c. These are the direct
97 operations mentioned above. As the name suggests they follow a
98 different principle than the rest of redisplay. Instead of
99 building a desired matrix and then comparing it with the current
100 display, they perform their actions directly on the display and on
103 One direct operation updates the display after one character has
104 been entered. The other one moves the cursor by one position
105 forward or backward. You find these functions under the names
106 `direct_output_for_insert' and `direct_output_forward_char' in
112 Desired matrices are always built per Emacs window. The function
113 `display_line' is the central function to look at if you are
114 interested. It constructs one row in a desired matrix given an
115 iterator structure containing both a buffer position and a
116 description of the environment in which the text is to be
117 displayed. But this is too early, read on.
119 Characters and pixmaps displayed for a range of buffer text depend
120 on various settings of buffers and windows, on overlays and text
121 properties, on display tables, on selective display. The good news
122 is that all this hairy stuff is hidden behind a small set of
123 interface functions taking a iterator structure (struct it)
126 Iteration over things to be displayed is then simple. It is
127 started by initializing an iterator with a call to init_iterator.
128 Calls to get_next_display_element fill the iterator structure with
129 relevant information about the next thing to display. Calls to
130 set_iterator_to_next move the iterator to the next thing.
132 Besides this, an iterator also contains information about the
133 display environment in which glyphs for display elements are to be
134 produced. It has fields for the width and height of the display,
135 the information whether long lines are truncated or continued, a
136 current X and Y position, and lots of other stuff you can better
139 Glyphs in a desired matrix are normally constructed in a loop
140 calling get_next_display_element and then produce_glyphs. The call
141 to produce_glyphs will fill the iterator structure with pixel
142 information about the element being displayed and at the same time
143 produce glyphs for it. If the display element fits on the line
144 being displayed, set_iterator_to_next is called next, otherwise the
145 glyphs produced are discarded.
150 That just couldn't be all, could it? What about terminal types not
151 supporting operations on sub-windows of the screen? To update the
152 display on such a terminal, window-based glyph matrices are not
153 well suited. To be able to reuse part of the display (scrolling
154 lines up and down), we must instead have a view of the whole
155 screen. This is what `frame matrices' are for. They are a trick.
157 Frames on terminals like above have a glyph pool. Windows on such
158 a frame sub-allocate their glyph memory from their frame's glyph
159 pool. The frame itself is given its own glyph matrices. By
160 coincidence---or maybe something else---rows in window glyph
161 matrices are slices of corresponding rows in frame matrices. Thus
162 writing to window matrices implicitly updates a frame matrix which
163 provides us with the view of the whole screen that we originally
164 wanted to have without having to move many bytes around. To be
165 honest, there is a little bit more done, but not much more. If you
166 plan to extend that code, take a look at dispnew.c. The function
167 build_frame_matrix is a good starting point. */
173 #include "keyboard.h"
176 #include "termchar.h"
177 #include "dispextern.h"
181 #include "commands.h"
184 #include "termhooks.h"
185 #include "intervals.h"
188 #include "region-cache.h"
191 #ifdef HAVE_X_WINDOWS
201 #define INFINITY 10000000
203 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
204 extern void set_frame_menubar
P_ ((struct frame
*f
, int, int));
205 extern int pending_menu_activation
;
208 extern int interrupt_input
;
209 extern int command_loop_level
;
211 extern int minibuffer_auto_raise
;
213 extern Lisp_Object Qface
;
214 extern Lisp_Object Qmode_line
, Qmode_line_inactive
, Qheader_line
;
216 extern Lisp_Object Voverriding_local_map
;
217 extern Lisp_Object Voverriding_local_map_menu_flag
;
218 extern Lisp_Object Qmenu_item
;
220 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
221 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
222 Lisp_Object Qredisplay_end_trigger_functions
;
223 Lisp_Object Qinhibit_point_motion_hooks
;
224 Lisp_Object QCeval
, Qwhen
, QCfile
, QCdata
, QCpropertize
;
225 Lisp_Object Qfontified
;
226 Lisp_Object Qgrow_only
;
227 Lisp_Object Qinhibit_eval_during_redisplay
;
228 Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
230 Lisp_Object Qrisky_local_variable
;
232 /* Holds the list (error). */
233 Lisp_Object list_of_error
;
235 /* Functions called to fontify regions of text. */
237 Lisp_Object Vfontification_functions
;
238 Lisp_Object Qfontification_functions
;
240 /* Non-zero means draw tool bar buttons raised when the mouse moves
243 int auto_raise_tool_bar_buttons_p
;
245 /* Margin around tool bar buttons in pixels. */
247 Lisp_Object Vtool_bar_button_margin
;
249 /* Thickness of shadow to draw around tool bar buttons. */
251 EMACS_INT tool_bar_button_relief
;
253 /* Non-zero means automatically resize tool-bars so that all tool-bar
254 items are visible, and no blank lines remain. */
256 int auto_resize_tool_bars_p
;
258 /* Non-nil means don't actually do any redisplay. */
260 Lisp_Object Vinhibit_redisplay
, Qinhibit_redisplay
;
262 /* Non-zero means Lisp evaluation during redisplay is inhibited. */
264 int inhibit_eval_during_redisplay
;
266 /* Names of text properties relevant for redisplay. */
268 Lisp_Object Qdisplay
, Qrelative_width
, Qalign_to
;
269 extern Lisp_Object Qface
, Qinvisible
, Qwidth
;
271 /* Symbols used in text property values. */
273 Lisp_Object Qspace
, QCalign_to
, QCrelative_width
, QCrelative_height
;
274 Lisp_Object Qleft_margin
, Qright_margin
, Qspace_width
, Qraise
;
276 extern Lisp_Object Qheight
;
278 /* Non-nil means highlight trailing whitespace. */
280 Lisp_Object Vshow_trailing_whitespace
;
282 /* Name of the face used to highlight trailing whitespace. */
284 Lisp_Object Qtrailing_whitespace
;
286 /* The symbol `image' which is the car of the lists used to represent
291 /* Non-zero means print newline to stdout before next mini-buffer
294 int noninteractive_need_newline
;
296 /* Non-zero means print newline to message log before next message. */
298 static int message_log_need_newline
;
300 /* Three markers that message_dolog uses.
301 It could allocate them itself, but that causes trouble
302 in handling memory-full errors. */
303 static Lisp_Object message_dolog_marker1
;
304 static Lisp_Object message_dolog_marker2
;
305 static Lisp_Object message_dolog_marker3
;
307 /* The buffer position of the first character appearing entirely or
308 partially on the line of the selected window which contains the
309 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
310 redisplay optimization in redisplay_internal. */
312 static struct text_pos this_line_start_pos
;
314 /* Number of characters past the end of the line above, including the
315 terminating newline. */
317 static struct text_pos this_line_end_pos
;
319 /* The vertical positions and the height of this line. */
321 static int this_line_vpos
;
322 static int this_line_y
;
323 static int this_line_pixel_height
;
325 /* X position at which this display line starts. Usually zero;
326 negative if first character is partially visible. */
328 static int this_line_start_x
;
330 /* Buffer that this_line_.* variables are referring to. */
332 static struct buffer
*this_line_buffer
;
334 /* Nonzero means truncate lines in all windows less wide than the
337 int truncate_partial_width_windows
;
339 /* A flag to control how to display unibyte 8-bit character. */
341 int unibyte_display_via_language_environment
;
343 /* Nonzero means we have more than one non-mini-buffer-only frame.
344 Not guaranteed to be accurate except while parsing
345 frame-title-format. */
349 Lisp_Object Vglobal_mode_string
;
351 /* Marker for where to display an arrow on top of the buffer text. */
353 Lisp_Object Voverlay_arrow_position
;
355 /* String to display for the arrow. Only used on terminal frames. */
357 Lisp_Object Voverlay_arrow_string
;
359 /* Values of those variables at last redisplay. However, if
360 Voverlay_arrow_position is a marker, last_arrow_position is its
361 numerical position. */
363 static Lisp_Object last_arrow_position
, last_arrow_string
;
365 /* Like mode-line-format, but for the title bar on a visible frame. */
367 Lisp_Object Vframe_title_format
;
369 /* Like mode-line-format, but for the title bar on an iconified frame. */
371 Lisp_Object Vicon_title_format
;
373 /* List of functions to call when a window's size changes. These
374 functions get one arg, a frame on which one or more windows' sizes
377 static Lisp_Object Vwindow_size_change_functions
;
379 Lisp_Object Qmenu_bar_update_hook
, Vmenu_bar_update_hook
;
381 /* Nonzero if overlay arrow has been displayed once in this window. */
383 static int overlay_arrow_seen
;
385 /* Nonzero means highlight the region even in nonselected windows. */
387 int highlight_nonselected_windows
;
389 /* If cursor motion alone moves point off frame, try scrolling this
390 many lines up or down if that will bring it back. */
392 static EMACS_INT scroll_step
;
394 /* Nonzero means scroll just far enough to bring point back on the
395 screen, when appropriate. */
397 static EMACS_INT scroll_conservatively
;
399 /* Recenter the window whenever point gets within this many lines of
400 the top or bottom of the window. This value is translated into a
401 pixel value by multiplying it with CANON_Y_UNIT, which means that
402 there is really a fixed pixel height scroll margin. */
404 EMACS_INT scroll_margin
;
406 /* Number of windows showing the buffer of the selected window (or
407 another buffer with the same base buffer). keyboard.c refers to
412 /* Vector containing glyphs for an ellipsis `...'. */
414 static Lisp_Object default_invis_vector
[3];
416 /* Zero means display the mode-line/header-line/menu-bar in the default face
417 (this slightly odd definition is for compatibility with previous versions
418 of emacs), non-zero means display them using their respective faces.
420 This variable is deprecated. */
422 int mode_line_inverse_video
;
424 /* Prompt to display in front of the mini-buffer contents. */
426 Lisp_Object minibuf_prompt
;
428 /* Width of current mini-buffer prompt. Only set after display_line
429 of the line that contains the prompt. */
431 int minibuf_prompt_width
;
433 /* This is the window where the echo area message was displayed. It
434 is always a mini-buffer window, but it may not be the same window
435 currently active as a mini-buffer. */
437 Lisp_Object echo_area_window
;
439 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
440 pushes the current message and the value of
441 message_enable_multibyte on the stack, the function restore_message
442 pops the stack and displays MESSAGE again. */
444 Lisp_Object Vmessage_stack
;
446 /* Nonzero means multibyte characters were enabled when the echo area
447 message was specified. */
449 int message_enable_multibyte
;
451 /* Nonzero if we should redraw the mode lines on the next redisplay. */
453 int update_mode_lines
;
455 /* Nonzero if window sizes or contents have changed since last
456 redisplay that finished. */
458 int windows_or_buffers_changed
;
460 /* Nonzero means a frame's cursor type has been changed. */
462 int cursor_type_changed
;
464 /* Nonzero after display_mode_line if %l was used and it displayed a
467 int line_number_displayed
;
469 /* Maximum buffer size for which to display line numbers. */
471 Lisp_Object Vline_number_display_limit
;
473 /* Line width to consider when repositioning for line number display. */
475 static EMACS_INT line_number_display_limit_width
;
477 /* Number of lines to keep in the message log buffer. t means
478 infinite. nil means don't log at all. */
480 Lisp_Object Vmessage_log_max
;
482 /* The name of the *Messages* buffer, a string. */
484 static Lisp_Object Vmessages_buffer_name
;
486 /* Current, index 0, and last displayed echo area message. Either
487 buffers from echo_buffers, or nil to indicate no message. */
489 Lisp_Object echo_area_buffer
[2];
491 /* The buffers referenced from echo_area_buffer. */
493 static Lisp_Object echo_buffer
[2];
495 /* A vector saved used in with_area_buffer to reduce consing. */
497 static Lisp_Object Vwith_echo_area_save_vector
;
499 /* Non-zero means display_echo_area should display the last echo area
500 message again. Set by redisplay_preserve_echo_area. */
502 static int display_last_displayed_message_p
;
504 /* Nonzero if echo area is being used by print; zero if being used by
507 int message_buf_print
;
509 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
511 Lisp_Object Qinhibit_menubar_update
;
512 int inhibit_menubar_update
;
514 /* Maximum height for resizing mini-windows. Either a float
515 specifying a fraction of the available height, or an integer
516 specifying a number of lines. */
518 Lisp_Object Vmax_mini_window_height
;
520 /* Non-zero means messages should be displayed with truncated
521 lines instead of being continued. */
523 int message_truncate_lines
;
524 Lisp_Object Qmessage_truncate_lines
;
526 /* Set to 1 in clear_message to make redisplay_internal aware
527 of an emptied echo area. */
529 static int message_cleared_p
;
531 /* Non-zero means we want a hollow cursor in windows that are not
532 selected. Zero means there's no cursor in such windows. */
534 int cursor_in_non_selected_windows
;
535 Lisp_Object Qcursor_in_non_selected_windows
;
537 /* A scratch glyph row with contents used for generating truncation
538 glyphs. Also used in direct_output_for_insert. */
540 #define MAX_SCRATCH_GLYPHS 100
541 struct glyph_row scratch_glyph_row
;
542 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
544 /* Ascent and height of the last line processed by move_it_to. */
546 static int last_max_ascent
, last_height
;
548 /* Non-zero if there's a help-echo in the echo area. */
550 int help_echo_showing_p
;
552 /* If >= 0, computed, exact values of mode-line and header-line height
553 to use in the macros CURRENT_MODE_LINE_HEIGHT and
554 CURRENT_HEADER_LINE_HEIGHT. */
556 int current_mode_line_height
, current_header_line_height
;
558 /* The maximum distance to look ahead for text properties. Values
559 that are too small let us call compute_char_face and similar
560 functions too often which is expensive. Values that are too large
561 let us call compute_char_face and alike too often because we
562 might not be interested in text properties that far away. */
564 #define TEXT_PROP_DISTANCE_LIMIT 100
568 /* Variables to turn off display optimizations from Lisp. */
570 int inhibit_try_window_id
, inhibit_try_window_reusing
;
571 int inhibit_try_cursor_movement
;
573 /* Non-zero means print traces of redisplay if compiled with
576 int trace_redisplay_p
;
578 #endif /* GLYPH_DEBUG */
580 #ifdef DEBUG_TRACE_MOVE
581 /* Non-zero means trace with TRACE_MOVE to stderr. */
584 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
586 #define TRACE_MOVE(x) (void) 0
589 /* Non-zero means automatically scroll windows horizontally to make
592 int automatic_hscrolling_p
;
594 /* How close to the margin can point get before the window is scrolled
596 EMACS_INT hscroll_margin
;
598 /* How much to scroll horizontally when point is inside the above margin. */
599 Lisp_Object Vhscroll_step
;
601 /* A list of symbols, one for each supported image type. */
603 Lisp_Object Vimage_types
;
605 /* The variable `resize-mini-windows'. If nil, don't resize
606 mini-windows. If t, always resize them to fit the text they
607 display. If `grow-only', let mini-windows grow only until they
610 Lisp_Object Vresize_mini_windows
;
612 /* Buffer being redisplayed -- for redisplay_window_error. */
614 struct buffer
*displayed_buffer
;
616 /* Value returned from text property handlers (see below). */
621 HANDLED_RECOMPUTE_PROPS
,
622 HANDLED_OVERLAY_STRING_CONSUMED
,
626 /* A description of text properties that redisplay is interested
631 /* The name of the property. */
634 /* A unique index for the property. */
637 /* A handler function called to set up iterator IT from the property
638 at IT's current position. Value is used to steer handle_stop. */
639 enum prop_handled (*handler
) P_ ((struct it
*it
));
642 static enum prop_handled handle_face_prop
P_ ((struct it
*));
643 static enum prop_handled handle_invisible_prop
P_ ((struct it
*));
644 static enum prop_handled handle_display_prop
P_ ((struct it
*));
645 static enum prop_handled handle_composition_prop
P_ ((struct it
*));
646 static enum prop_handled handle_overlay_change
P_ ((struct it
*));
647 static enum prop_handled handle_fontified_prop
P_ ((struct it
*));
649 /* Properties handled by iterators. */
651 static struct props it_props
[] =
653 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
654 /* Handle `face' before `display' because some sub-properties of
655 `display' need to know the face. */
656 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
657 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
658 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
659 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
663 /* Value is the position described by X. If X is a marker, value is
664 the marker_position of X. Otherwise, value is X. */
666 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
668 /* Enumeration returned by some move_it_.* functions internally. */
672 /* Not used. Undefined value. */
675 /* Move ended at the requested buffer position or ZV. */
676 MOVE_POS_MATCH_OR_ZV
,
678 /* Move ended at the requested X pixel position. */
681 /* Move within a line ended at the end of a line that must be
685 /* Move within a line ended at the end of a line that would
686 be displayed truncated. */
689 /* Move within a line ended at a line end. */
695 /* Function prototypes. */
697 static void setup_for_ellipsis
P_ ((struct it
*));
698 static void mark_window_display_accurate_1
P_ ((struct window
*, int));
699 static int single_display_prop_string_p
P_ ((Lisp_Object
, Lisp_Object
));
700 static int display_prop_string_p
P_ ((Lisp_Object
, Lisp_Object
));
701 static int cursor_row_p
P_ ((struct window
*, struct glyph_row
*));
702 static int redisplay_mode_lines
P_ ((Lisp_Object
, int));
703 static char *decode_mode_spec_coding
P_ ((Lisp_Object
, char *, int));
706 static int invisible_text_between_p
P_ ((struct it
*, int, int));
709 static int next_element_from_ellipsis
P_ ((struct it
*));
710 static void pint2str
P_ ((char *, int, int));
711 static struct text_pos run_window_scroll_functions
P_ ((Lisp_Object
,
713 static void reconsider_clip_changes
P_ ((struct window
*, struct buffer
*));
714 static int text_outside_line_unchanged_p
P_ ((struct window
*, int, int));
715 static void store_frame_title_char
P_ ((char));
716 static int store_frame_title
P_ ((const unsigned char *, int, int));
717 static void x_consider_frame_title
P_ ((Lisp_Object
));
718 static void handle_stop
P_ ((struct it
*));
719 static int tool_bar_lines_needed
P_ ((struct frame
*));
720 static int single_display_prop_intangible_p
P_ ((Lisp_Object
));
721 static void ensure_echo_area_buffers
P_ ((void));
722 static Lisp_Object unwind_with_echo_area_buffer
P_ ((Lisp_Object
));
723 static Lisp_Object with_echo_area_buffer_unwind_data
P_ ((struct window
*));
724 static int with_echo_area_buffer
P_ ((struct window
*, int,
725 int (*) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
726 EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
727 static void clear_garbaged_frames
P_ ((void));
728 static int current_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
729 static int truncate_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
730 static int set_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
731 static int display_echo_area
P_ ((struct window
*));
732 static int display_echo_area_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
733 static int resize_mini_window_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
734 static Lisp_Object unwind_redisplay
P_ ((Lisp_Object
));
735 static int string_char_and_length
P_ ((const unsigned char *, int, int *));
736 static struct text_pos display_prop_end
P_ ((struct it
*, Lisp_Object
,
738 static int compute_window_start_on_continuation_line
P_ ((struct window
*));
739 static Lisp_Object safe_eval_handler
P_ ((Lisp_Object
));
740 static void insert_left_trunc_glyphs
P_ ((struct it
*));
741 static struct glyph_row
*get_overlay_arrow_glyph_row
P_ ((struct window
*));
742 static void extend_face_to_end_of_line
P_ ((struct it
*));
743 static int append_space
P_ ((struct it
*, int));
744 static int make_cursor_line_fully_visible
P_ ((struct window
*));
745 static int try_scrolling
P_ ((Lisp_Object
, int, EMACS_INT
, EMACS_INT
, int));
746 static int try_cursor_movement
P_ ((Lisp_Object
, struct text_pos
, int *));
747 static int trailing_whitespace_p
P_ ((int));
748 static int message_log_check_duplicate
P_ ((int, int, int, int));
749 static void push_it
P_ ((struct it
*));
750 static void pop_it
P_ ((struct it
*));
751 static void sync_frame_with_window_matrix_rows
P_ ((struct window
*));
752 static void redisplay_internal
P_ ((int));
753 static int echo_area_display
P_ ((int));
754 static void redisplay_windows
P_ ((Lisp_Object
));
755 static void redisplay_window
P_ ((Lisp_Object
, int));
756 static Lisp_Object
redisplay_window_error ();
757 static Lisp_Object redisplay_window_0
P_ ((Lisp_Object
));
758 static Lisp_Object redisplay_window_1
P_ ((Lisp_Object
));
759 static void update_menu_bar
P_ ((struct frame
*, int));
760 static int try_window_reusing_current_matrix
P_ ((struct window
*));
761 static int try_window_id
P_ ((struct window
*));
762 static int display_line
P_ ((struct it
*));
763 static int display_mode_lines
P_ ((struct window
*));
764 static int display_mode_line
P_ ((struct window
*, enum face_id
, Lisp_Object
));
765 static int display_mode_element
P_ ((struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int));
766 static int store_mode_line_string
P_ ((char *, Lisp_Object
, int, int, int, Lisp_Object
));
767 static char *decode_mode_spec
P_ ((struct window
*, int, int, int, int *));
768 static void display_menu_bar
P_ ((struct window
*));
769 static int display_count_lines
P_ ((int, int, int, int, int *));
770 static int display_string
P_ ((unsigned char *, Lisp_Object
, Lisp_Object
,
771 int, int, struct it
*, int, int, int, int));
772 static void compute_line_metrics
P_ ((struct it
*));
773 static void run_redisplay_end_trigger_hook
P_ ((struct it
*));
774 static int get_overlay_strings
P_ ((struct it
*, int));
775 static void next_overlay_string
P_ ((struct it
*));
776 static void reseat
P_ ((struct it
*, struct text_pos
, int));
777 static void reseat_1
P_ ((struct it
*, struct text_pos
, int));
778 static void back_to_previous_visible_line_start
P_ ((struct it
*));
779 static void reseat_at_previous_visible_line_start
P_ ((struct it
*));
780 static void reseat_at_next_visible_line_start
P_ ((struct it
*, int));
781 static int next_element_from_display_vector
P_ ((struct it
*));
782 static int next_element_from_string
P_ ((struct it
*));
783 static int next_element_from_c_string
P_ ((struct it
*));
784 static int next_element_from_buffer
P_ ((struct it
*));
785 static int next_element_from_composition
P_ ((struct it
*));
786 static int next_element_from_image
P_ ((struct it
*));
787 static int next_element_from_stretch
P_ ((struct it
*));
788 static void load_overlay_strings
P_ ((struct it
*, int));
789 static int init_from_display_pos
P_ ((struct it
*, struct window
*,
790 struct display_pos
*));
791 static void reseat_to_string
P_ ((struct it
*, unsigned char *,
792 Lisp_Object
, int, int, int, int));
793 static enum move_it_result move_it_in_display_line_to
P_ ((struct it
*,
795 void move_it_vertically_backward
P_ ((struct it
*, int));
796 static void init_to_row_start
P_ ((struct it
*, struct window
*,
797 struct glyph_row
*));
798 static int init_to_row_end
P_ ((struct it
*, struct window
*,
799 struct glyph_row
*));
800 static void back_to_previous_line_start
P_ ((struct it
*));
801 static int forward_to_next_line_start
P_ ((struct it
*, int *));
802 static struct text_pos string_pos_nchars_ahead
P_ ((struct text_pos
,
804 static struct text_pos string_pos
P_ ((int, Lisp_Object
));
805 static struct text_pos c_string_pos
P_ ((int, unsigned char *, int));
806 static int number_of_chars
P_ ((unsigned char *, int));
807 static void compute_stop_pos
P_ ((struct it
*));
808 static void compute_string_pos
P_ ((struct text_pos
*, struct text_pos
,
810 static int face_before_or_after_it_pos
P_ ((struct it
*, int));
811 static int next_overlay_change
P_ ((int));
812 static int handle_single_display_prop
P_ ((struct it
*, Lisp_Object
,
813 Lisp_Object
, struct text_pos
*,
815 static int underlying_face_id
P_ ((struct it
*));
816 static int in_ellipses_for_invisible_text_p
P_ ((struct display_pos
*,
819 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
820 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
822 #ifdef HAVE_WINDOW_SYSTEM
824 static void update_tool_bar
P_ ((struct frame
*, int));
825 static void build_desired_tool_bar_string
P_ ((struct frame
*f
));
826 static int redisplay_tool_bar
P_ ((struct frame
*));
827 static void display_tool_bar_line
P_ ((struct it
*));
829 #endif /* HAVE_WINDOW_SYSTEM */
832 /***********************************************************************
833 Window display dimensions
834 ***********************************************************************/
836 /* Return the window-relative maximum y + 1 for glyph rows displaying
837 text in window W. This is the height of W minus the height of a
838 mode line, if any. */
841 window_text_bottom_y (w
)
844 struct frame
*f
= XFRAME (w
->frame
);
845 int height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
847 if (WINDOW_WANTS_MODELINE_P (w
))
848 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
853 /* Return the pixel width of display area AREA of window W. AREA < 0
854 means return the total width of W, not including fringes to
855 the left and right of the window. */
858 window_box_width (w
, area
)
862 struct frame
*f
= XFRAME (w
->frame
);
863 int width
= XFASTINT (w
->width
);
865 if (!w
->pseudo_window_p
)
867 width
-= FRAME_SCROLL_BAR_WIDTH (f
) + FRAME_FRINGE_COLS (f
);
869 if (area
== TEXT_AREA
)
871 if (INTEGERP (w
->left_margin_width
))
872 width
-= XFASTINT (w
->left_margin_width
);
873 if (INTEGERP (w
->right_margin_width
))
874 width
-= XFASTINT (w
->right_margin_width
);
876 else if (area
== LEFT_MARGIN_AREA
)
877 width
= (INTEGERP (w
->left_margin_width
)
878 ? XFASTINT (w
->left_margin_width
) : 0);
879 else if (area
== RIGHT_MARGIN_AREA
)
880 width
= (INTEGERP (w
->right_margin_width
)
881 ? XFASTINT (w
->right_margin_width
) : 0);
884 return width
* CANON_X_UNIT (f
);
888 /* Return the pixel height of the display area of window W, not
889 including mode lines of W, if any. */
892 window_box_height (w
)
895 struct frame
*f
= XFRAME (w
->frame
);
896 int height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
898 xassert (height
>= 0);
900 /* Note: the code below that determines the mode-line/header-line
901 height is essentially the same as that contained in the macro
902 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
903 the appropriate glyph row has its `mode_line_p' flag set,
904 and if it doesn't, uses estimate_mode_line_height instead. */
906 if (WINDOW_WANTS_MODELINE_P (w
))
908 struct glyph_row
*ml_row
909 = (w
->current_matrix
&& w
->current_matrix
->rows
910 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
912 if (ml_row
&& ml_row
->mode_line_p
)
913 height
-= ml_row
->height
;
915 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
918 if (WINDOW_WANTS_HEADER_LINE_P (w
))
920 struct glyph_row
*hl_row
921 = (w
->current_matrix
&& w
->current_matrix
->rows
922 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
924 if (hl_row
&& hl_row
->mode_line_p
)
925 height
-= hl_row
->height
;
927 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
930 /* With a very small font and a mode-line that's taller than
931 default, we might end up with a negative height. */
932 return max (0, height
);
936 /* Return the frame-relative coordinate of the left edge of display
937 area AREA of window W. AREA < 0 means return the left edge of the
938 whole window, to the right of the left fringe of W. */
941 window_box_left (w
, area
)
945 struct frame
*f
= XFRAME (w
->frame
);
946 int x
= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
948 if (!w
->pseudo_window_p
)
950 x
+= (WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
)
951 + FRAME_LEFT_FRINGE_WIDTH (f
));
953 if (area
== TEXT_AREA
)
954 x
+= window_box_width (w
, LEFT_MARGIN_AREA
);
955 else if (area
== RIGHT_MARGIN_AREA
)
956 x
+= (window_box_width (w
, LEFT_MARGIN_AREA
)
957 + window_box_width (w
, TEXT_AREA
));
964 /* Return the frame-relative coordinate of the right edge of display
965 area AREA of window W. AREA < 0 means return the left edge of the
966 whole window, to the left of the right fringe of W. */
969 window_box_right (w
, area
)
973 return window_box_left (w
, area
) + window_box_width (w
, area
);
977 /* Get the bounding box of the display area AREA of window W, without
978 mode lines, in frame-relative coordinates. AREA < 0 means the
979 whole window, not including the left and right fringes of
980 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
981 coordinates of the upper-left corner of the box. Return in
982 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
985 window_box (w
, area
, box_x
, box_y
, box_width
, box_height
)
988 int *box_x
, *box_y
, *box_width
, *box_height
;
990 struct frame
*f
= XFRAME (w
->frame
);
992 *box_width
= window_box_width (w
, area
);
993 *box_height
= window_box_height (w
);
994 *box_x
= window_box_left (w
, area
);
995 *box_y
= (FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
)
996 + XFASTINT (w
->top
) * CANON_Y_UNIT (f
));
997 if (WINDOW_WANTS_HEADER_LINE_P (w
))
998 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1002 /* Get the bounding box of the display area AREA of window W, without
1003 mode lines. AREA < 0 means the whole window, not including the
1004 left and right fringe of the window. Return in *TOP_LEFT_X
1005 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1006 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1007 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1011 window_box_edges (w
, area
, top_left_x
, top_left_y
,
1012 bottom_right_x
, bottom_right_y
)
1015 int *top_left_x
, *top_left_y
, *bottom_right_x
, *bottom_right_y
;
1017 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1019 *bottom_right_x
+= *top_left_x
;
1020 *bottom_right_y
+= *top_left_y
;
1025 /***********************************************************************
1027 ***********************************************************************/
1029 /* Return the bottom y-position of the line the iterator IT is in.
1030 This can modify IT's settings. */
1036 int line_height
= it
->max_ascent
+ it
->max_descent
;
1037 int line_top_y
= it
->current_y
;
1039 if (line_height
== 0)
1042 line_height
= last_height
;
1043 else if (IT_CHARPOS (*it
) < ZV
)
1045 move_it_by_lines (it
, 1, 1);
1046 line_height
= (it
->max_ascent
|| it
->max_descent
1047 ? it
->max_ascent
+ it
->max_descent
1052 struct glyph_row
*row
= it
->glyph_row
;
1054 /* Use the default character height. */
1055 it
->glyph_row
= NULL
;
1056 it
->what
= IT_CHARACTER
;
1059 PRODUCE_GLYPHS (it
);
1060 line_height
= it
->ascent
+ it
->descent
;
1061 it
->glyph_row
= row
;
1065 return line_top_y
+ line_height
;
1069 /* Return 1 if position CHARPOS is visible in window W. Set *FULLY to
1070 1 if POS is visible and the line containing POS is fully visible.
1071 EXACT_MODE_LINE_HEIGHTS_P non-zero means compute exact mode-line
1072 and header-lines heights. */
1075 pos_visible_p (w
, charpos
, fully
, exact_mode_line_heights_p
)
1077 int charpos
, *fully
, exact_mode_line_heights_p
;
1080 struct text_pos top
;
1082 struct buffer
*old_buffer
= NULL
;
1084 if (XBUFFER (w
->buffer
) != current_buffer
)
1086 old_buffer
= current_buffer
;
1087 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1090 *fully
= visible_p
= 0;
1091 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1093 /* Compute exact mode line heights, if requested. */
1094 if (exact_mode_line_heights_p
)
1096 if (WINDOW_WANTS_MODELINE_P (w
))
1097 current_mode_line_height
1098 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1099 current_buffer
->mode_line_format
);
1101 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1102 current_header_line_height
1103 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1104 current_buffer
->header_line_format
);
1107 start_display (&it
, w
, top
);
1108 move_it_to (&it
, charpos
, 0, it
.last_visible_y
, -1,
1109 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
1111 /* Note that we may overshoot because of invisible text. */
1112 if (IT_CHARPOS (it
) >= charpos
)
1114 int top_y
= it
.current_y
;
1115 int bottom_y
= line_bottom_y (&it
);
1116 int window_top_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1118 if (top_y
< window_top_y
)
1119 visible_p
= bottom_y
> window_top_y
;
1120 else if (top_y
< it
.last_visible_y
)
1123 *fully
= bottom_y
<= it
.last_visible_y
;
1126 else if (it
.current_y
+ it
.max_ascent
+ it
.max_descent
> it
.last_visible_y
)
1128 move_it_by_lines (&it
, 1, 0);
1129 if (charpos
< IT_CHARPOS (it
))
1137 set_buffer_internal_1 (old_buffer
);
1139 current_header_line_height
= current_mode_line_height
= -1;
1144 /* Return the next character from STR which is MAXLEN bytes long.
1145 Return in *LEN the length of the character. This is like
1146 STRING_CHAR_AND_LENGTH but never returns an invalid character. If
1147 we find one, we return a `?', but with the length of the invalid
1151 string_char_and_length (str
, maxlen
, len
)
1152 const unsigned char *str
;
1157 c
= STRING_CHAR_AND_LENGTH (str
, maxlen
, *len
);
1158 if (!CHAR_VALID_P (c
, 1))
1159 /* We may not change the length here because other places in Emacs
1160 don't use this function, i.e. they silently accept invalid
1169 /* Given a position POS containing a valid character and byte position
1170 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1172 static struct text_pos
1173 string_pos_nchars_ahead (pos
, string
, nchars
)
1174 struct text_pos pos
;
1178 xassert (STRINGP (string
) && nchars
>= 0);
1180 if (STRING_MULTIBYTE (string
))
1182 int rest
= SBYTES (string
) - BYTEPOS (pos
);
1183 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1188 string_char_and_length (p
, rest
, &len
);
1189 p
+= len
, rest
-= len
;
1190 xassert (rest
>= 0);
1192 BYTEPOS (pos
) += len
;
1196 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1202 /* Value is the text position, i.e. character and byte position,
1203 for character position CHARPOS in STRING. */
1205 static INLINE
struct text_pos
1206 string_pos (charpos
, string
)
1210 struct text_pos pos
;
1211 xassert (STRINGP (string
));
1212 xassert (charpos
>= 0);
1213 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1218 /* Value is a text position, i.e. character and byte position, for
1219 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1220 means recognize multibyte characters. */
1222 static struct text_pos
1223 c_string_pos (charpos
, s
, multibyte_p
)
1228 struct text_pos pos
;
1230 xassert (s
!= NULL
);
1231 xassert (charpos
>= 0);
1235 int rest
= strlen (s
), len
;
1237 SET_TEXT_POS (pos
, 0, 0);
1240 string_char_and_length (s
, rest
, &len
);
1241 s
+= len
, rest
-= len
;
1242 xassert (rest
>= 0);
1244 BYTEPOS (pos
) += len
;
1248 SET_TEXT_POS (pos
, charpos
, charpos
);
1254 /* Value is the number of characters in C string S. MULTIBYTE_P
1255 non-zero means recognize multibyte characters. */
1258 number_of_chars (s
, multibyte_p
)
1266 int rest
= strlen (s
), len
;
1267 unsigned char *p
= (unsigned char *) s
;
1269 for (nchars
= 0; rest
> 0; ++nchars
)
1271 string_char_and_length (p
, rest
, &len
);
1272 rest
-= len
, p
+= len
;
1276 nchars
= strlen (s
);
1282 /* Compute byte position NEWPOS->bytepos corresponding to
1283 NEWPOS->charpos. POS is a known position in string STRING.
1284 NEWPOS->charpos must be >= POS.charpos. */
1287 compute_string_pos (newpos
, pos
, string
)
1288 struct text_pos
*newpos
, pos
;
1291 xassert (STRINGP (string
));
1292 xassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1294 if (STRING_MULTIBYTE (string
))
1295 *newpos
= string_pos_nchars_ahead (pos
, string
,
1296 CHARPOS (*newpos
) - CHARPOS (pos
));
1298 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1303 /***********************************************************************
1304 Lisp form evaluation
1305 ***********************************************************************/
1307 /* Error handler for safe_eval and safe_call. */
1310 safe_eval_handler (arg
)
1313 add_to_log ("Error during redisplay: %s", arg
, Qnil
);
1318 /* Evaluate SEXPR and return the result, or nil if something went
1319 wrong. Prevent redisplay during the evaluation. */
1327 if (inhibit_eval_during_redisplay
)
1331 int count
= SPECPDL_INDEX ();
1332 struct gcpro gcpro1
;
1335 specbind (Qinhibit_redisplay
, Qt
);
1336 /* Use Qt to ensure debugger does not run,
1337 so there is no possibility of wanting to redisplay. */
1338 val
= internal_condition_case_1 (Feval
, sexpr
, Qt
,
1341 val
= unbind_to (count
, val
);
1348 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
1349 Return the result, or nil if something went wrong. Prevent
1350 redisplay during the evaluation. */
1353 safe_call (nargs
, args
)
1359 if (inhibit_eval_during_redisplay
)
1363 int count
= SPECPDL_INDEX ();
1364 struct gcpro gcpro1
;
1367 gcpro1
.nvars
= nargs
;
1368 specbind (Qinhibit_redisplay
, Qt
);
1369 /* Use Qt to ensure debugger does not run,
1370 so there is no possibility of wanting to redisplay. */
1371 val
= internal_condition_case_2 (Ffuncall
, nargs
, args
, Qt
,
1374 val
= unbind_to (count
, val
);
1381 /* Call function FN with one argument ARG.
1382 Return the result, or nil if something went wrong. */
1385 safe_call1 (fn
, arg
)
1386 Lisp_Object fn
, arg
;
1388 Lisp_Object args
[2];
1391 return safe_call (2, args
);
1396 /***********************************************************************
1398 ***********************************************************************/
1402 /* Define CHECK_IT to perform sanity checks on iterators.
1403 This is for debugging. It is too slow to do unconditionally. */
1409 if (it
->method
== next_element_from_string
)
1411 xassert (STRINGP (it
->string
));
1412 xassert (IT_STRING_CHARPOS (*it
) >= 0);
1414 else if (it
->method
== next_element_from_buffer
)
1416 /* Check that character and byte positions agree. */
1417 xassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
1421 xassert (it
->current
.dpvec_index
>= 0);
1423 xassert (it
->current
.dpvec_index
< 0);
1426 #define CHECK_IT(IT) check_it ((IT))
1430 #define CHECK_IT(IT) (void) 0
1437 /* Check that the window end of window W is what we expect it
1438 to be---the last row in the current matrix displaying text. */
1441 check_window_end (w
)
1444 if (!MINI_WINDOW_P (w
)
1445 && !NILP (w
->window_end_valid
))
1447 struct glyph_row
*row
;
1448 xassert ((row
= MATRIX_ROW (w
->current_matrix
,
1449 XFASTINT (w
->window_end_vpos
)),
1451 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1452 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
1456 #define CHECK_WINDOW_END(W) check_window_end ((W))
1458 #else /* not GLYPH_DEBUG */
1460 #define CHECK_WINDOW_END(W) (void) 0
1462 #endif /* not GLYPH_DEBUG */
1466 /***********************************************************************
1467 Iterator initialization
1468 ***********************************************************************/
1470 /* Initialize IT for displaying current_buffer in window W, starting
1471 at character position CHARPOS. CHARPOS < 0 means that no buffer
1472 position is specified which is useful when the iterator is assigned
1473 a position later. BYTEPOS is the byte position corresponding to
1474 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
1476 If ROW is not null, calls to produce_glyphs with IT as parameter
1477 will produce glyphs in that row.
1479 BASE_FACE_ID is the id of a base face to use. It must be one of
1480 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
1481 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
1482 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
1484 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
1485 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
1486 will be initialized to use the corresponding mode line glyph row of
1487 the desired matrix of W. */
1490 init_iterator (it
, w
, charpos
, bytepos
, row
, base_face_id
)
1493 int charpos
, bytepos
;
1494 struct glyph_row
*row
;
1495 enum face_id base_face_id
;
1497 int highlight_region_p
;
1499 /* Some precondition checks. */
1500 xassert (w
!= NULL
&& it
!= NULL
);
1501 xassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
1504 /* If face attributes have been changed since the last redisplay,
1505 free realized faces now because they depend on face definitions
1506 that might have changed. */
1507 if (face_change_count
)
1509 face_change_count
= 0;
1510 free_all_realized_faces (Qnil
);
1513 /* Use one of the mode line rows of W's desired matrix if
1517 if (base_face_id
== MODE_LINE_FACE_ID
1518 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
1519 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
1520 else if (base_face_id
== HEADER_LINE_FACE_ID
)
1521 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
1525 bzero (it
, sizeof *it
);
1526 it
->current
.overlay_string_index
= -1;
1527 it
->current
.dpvec_index
= -1;
1528 it
->base_face_id
= base_face_id
;
1530 /* The window in which we iterate over current_buffer: */
1531 XSETWINDOW (it
->window
, w
);
1533 it
->f
= XFRAME (w
->frame
);
1535 /* Extra space between lines (on window systems only). */
1536 if (base_face_id
== DEFAULT_FACE_ID
1537 && FRAME_WINDOW_P (it
->f
))
1539 if (NATNUMP (current_buffer
->extra_line_spacing
))
1540 it
->extra_line_spacing
= XFASTINT (current_buffer
->extra_line_spacing
);
1541 else if (it
->f
->extra_line_spacing
> 0)
1542 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
1545 /* If realized faces have been removed, e.g. because of face
1546 attribute changes of named faces, recompute them. When running
1547 in batch mode, the face cache of Vterminal_frame is null. If
1548 we happen to get called, make a dummy face cache. */
1553 FRAME_FACE_CACHE (it
->f
) == NULL
)
1554 init_frame_faces (it
->f
);
1555 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
1556 recompute_basic_faces (it
->f
);
1558 /* Current value of the `space-width', and 'height' properties. */
1559 it
->space_width
= Qnil
;
1560 it
->font_height
= Qnil
;
1562 /* Are control characters displayed as `^C'? */
1563 it
->ctl_arrow_p
= !NILP (current_buffer
->ctl_arrow
);
1565 /* -1 means everything between a CR and the following line end
1566 is invisible. >0 means lines indented more than this value are
1568 it
->selective
= (INTEGERP (current_buffer
->selective_display
)
1569 ? XFASTINT (current_buffer
->selective_display
)
1570 : (!NILP (current_buffer
->selective_display
)
1572 it
->selective_display_ellipsis_p
1573 = !NILP (current_buffer
->selective_display_ellipses
);
1575 /* Display table to use. */
1576 it
->dp
= window_display_table (w
);
1578 /* Are multibyte characters enabled in current_buffer? */
1579 it
->multibyte_p
= !NILP (current_buffer
->enable_multibyte_characters
);
1581 /* Non-zero if we should highlight the region. */
1583 = (!NILP (Vtransient_mark_mode
)
1584 && !NILP (current_buffer
->mark_active
)
1585 && XMARKER (current_buffer
->mark
)->buffer
!= 0);
1587 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
1588 start and end of a visible region in window IT->w. Set both to
1589 -1 to indicate no region. */
1590 if (highlight_region_p
1591 /* Maybe highlight only in selected window. */
1592 && (/* Either show region everywhere. */
1593 highlight_nonselected_windows
1594 /* Or show region in the selected window. */
1595 || w
== XWINDOW (selected_window
)
1596 /* Or show the region if we are in the mini-buffer and W is
1597 the window the mini-buffer refers to. */
1598 || (MINI_WINDOW_P (XWINDOW (selected_window
))
1599 && WINDOWP (minibuf_selected_window
)
1600 && w
== XWINDOW (minibuf_selected_window
))))
1602 int charpos
= marker_position (current_buffer
->mark
);
1603 it
->region_beg_charpos
= min (PT
, charpos
);
1604 it
->region_end_charpos
= max (PT
, charpos
);
1607 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
1609 /* Get the position at which the redisplay_end_trigger hook should
1610 be run, if it is to be run at all. */
1611 if (MARKERP (w
->redisplay_end_trigger
)
1612 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
1613 it
->redisplay_end_trigger_charpos
1614 = marker_position (w
->redisplay_end_trigger
);
1615 else if (INTEGERP (w
->redisplay_end_trigger
))
1616 it
->redisplay_end_trigger_charpos
= XINT (w
->redisplay_end_trigger
);
1618 /* Correct bogus values of tab_width. */
1619 it
->tab_width
= XINT (current_buffer
->tab_width
);
1620 if (it
->tab_width
<= 0 || it
->tab_width
> 1000)
1623 /* Are lines in the display truncated? */
1624 it
->truncate_lines_p
1625 = (base_face_id
!= DEFAULT_FACE_ID
1626 || XINT (it
->w
->hscroll
)
1627 || (truncate_partial_width_windows
1628 && !WINDOW_FULL_WIDTH_P (it
->w
))
1629 || !NILP (current_buffer
->truncate_lines
));
1631 /* Get dimensions of truncation and continuation glyphs. These are
1632 displayed as fringe bitmaps under X, so we don't need them for such
1634 if (!FRAME_WINDOW_P (it
->f
))
1636 if (it
->truncate_lines_p
)
1638 /* We will need the truncation glyph. */
1639 xassert (it
->glyph_row
== NULL
);
1640 produce_special_glyphs (it
, IT_TRUNCATION
);
1641 it
->truncation_pixel_width
= it
->pixel_width
;
1645 /* We will need the continuation glyph. */
1646 xassert (it
->glyph_row
== NULL
);
1647 produce_special_glyphs (it
, IT_CONTINUATION
);
1648 it
->continuation_pixel_width
= it
->pixel_width
;
1651 /* Reset these values to zero because the produce_special_glyphs
1652 above has changed them. */
1653 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
1654 it
->phys_ascent
= it
->phys_descent
= 0;
1657 /* Set this after getting the dimensions of truncation and
1658 continuation glyphs, so that we don't produce glyphs when calling
1659 produce_special_glyphs, above. */
1660 it
->glyph_row
= row
;
1661 it
->area
= TEXT_AREA
;
1663 /* Get the dimensions of the display area. The display area
1664 consists of the visible window area plus a horizontally scrolled
1665 part to the left of the window. All x-values are relative to the
1666 start of this total display area. */
1667 if (base_face_id
!= DEFAULT_FACE_ID
)
1669 /* Mode lines, menu bar in terminal frames. */
1670 it
->first_visible_x
= 0;
1671 it
->last_visible_x
= XFASTINT (w
->width
) * CANON_X_UNIT (it
->f
);
1676 = XFASTINT (it
->w
->hscroll
) * CANON_X_UNIT (it
->f
);
1677 it
->last_visible_x
= (it
->first_visible_x
1678 + window_box_width (w
, TEXT_AREA
));
1680 /* If we truncate lines, leave room for the truncator glyph(s) at
1681 the right margin. Otherwise, leave room for the continuation
1682 glyph(s). Truncation and continuation glyphs are not inserted
1683 for window-based redisplay. */
1684 if (!FRAME_WINDOW_P (it
->f
))
1686 if (it
->truncate_lines_p
)
1687 it
->last_visible_x
-= it
->truncation_pixel_width
;
1689 it
->last_visible_x
-= it
->continuation_pixel_width
;
1692 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
1693 it
->current_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
1696 /* Leave room for a border glyph. */
1697 if (!FRAME_WINDOW_P (it
->f
)
1698 && !WINDOW_RIGHTMOST_P (it
->w
))
1699 it
->last_visible_x
-= 1;
1701 it
->last_visible_y
= window_text_bottom_y (w
);
1703 /* For mode lines and alike, arrange for the first glyph having a
1704 left box line if the face specifies a box. */
1705 if (base_face_id
!= DEFAULT_FACE_ID
)
1709 it
->face_id
= base_face_id
;
1711 /* If we have a boxed mode line, make the first character appear
1712 with a left box line. */
1713 face
= FACE_FROM_ID (it
->f
, base_face_id
);
1714 if (face
->box
!= FACE_NO_BOX
)
1715 it
->start_of_box_run_p
= 1;
1718 /* If a buffer position was specified, set the iterator there,
1719 getting overlays and face properties from that position. */
1720 if (charpos
>= BUF_BEG (current_buffer
))
1722 it
->end_charpos
= ZV
;
1724 IT_CHARPOS (*it
) = charpos
;
1726 /* Compute byte position if not specified. */
1727 if (bytepos
< charpos
)
1728 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
1730 IT_BYTEPOS (*it
) = bytepos
;
1732 /* Compute faces etc. */
1733 reseat (it
, it
->current
.pos
, 1);
1740 /* Initialize IT for the display of window W with window start POS. */
1743 start_display (it
, w
, pos
)
1746 struct text_pos pos
;
1748 struct glyph_row
*row
;
1749 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
1751 row
= w
->desired_matrix
->rows
+ first_vpos
;
1752 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
1754 if (!it
->truncate_lines_p
)
1756 int start_at_line_beg_p
;
1757 int first_y
= it
->current_y
;
1759 /* If window start is not at a line start, skip forward to POS to
1760 get the correct continuation lines width. */
1761 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
1762 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
1763 if (!start_at_line_beg_p
)
1765 reseat_at_previous_visible_line_start (it
);
1766 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
1768 /* If lines are continued, this line may end in the middle
1769 of a multi-glyph character (e.g. a control character
1770 displayed as \003, or in the middle of an overlay
1771 string). In this case move_it_to above will not have
1772 taken us to the start of the continuation line but to the
1773 end of the continued line. */
1774 if (it
->current_x
> 0)
1776 if (it
->current
.dpvec_index
>= 0
1777 || it
->current
.overlay_string_index
>= 0)
1779 set_iterator_to_next (it
, 1);
1780 move_it_in_display_line_to (it
, -1, -1, 0);
1783 it
->continuation_lines_width
+= it
->current_x
;
1786 /* We're starting a new display line, not affected by the
1787 height of the continued line, so clear the appropriate
1788 fields in the iterator structure. */
1789 it
->max_ascent
= it
->max_descent
= 0;
1790 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
1792 it
->current_y
= first_y
;
1794 it
->current_x
= it
->hpos
= 0;
1798 #if 0 /* Don't assert the following because start_display is sometimes
1799 called intentionally with a window start that is not at a
1800 line start. Please leave this code in as a comment. */
1802 /* Window start should be on a line start, now. */
1803 xassert (it
->continuation_lines_width
1804 || IT_CHARPOS (it
) == BEGV
1805 || FETCH_BYTE (IT_BYTEPOS (it
) - 1) == '\n');
1810 /* Return 1 if POS is a position in ellipses displayed for invisible
1811 text. W is the window we display, for text property lookup. */
1814 in_ellipses_for_invisible_text_p (pos
, w
)
1815 struct display_pos
*pos
;
1818 Lisp_Object prop
, window
;
1820 int charpos
= CHARPOS (pos
->pos
);
1822 /* If POS specifies a position in a display vector, this might
1823 be for an ellipsis displayed for invisible text. We won't
1824 get the iterator set up for delivering that ellipsis unless
1825 we make sure that it gets aware of the invisible text. */
1826 if (pos
->dpvec_index
>= 0
1827 && pos
->overlay_string_index
< 0
1828 && CHARPOS (pos
->string_pos
) < 0
1830 && (XSETWINDOW (window
, w
),
1831 prop
= Fget_char_property (make_number (charpos
),
1832 Qinvisible
, window
),
1833 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
1835 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
1837 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
1844 /* Initialize IT for stepping through current_buffer in window W,
1845 starting at position POS that includes overlay string and display
1846 vector/ control character translation position information. Value
1847 is zero if there are overlay strings with newlines at POS. */
1850 init_from_display_pos (it
, w
, pos
)
1853 struct display_pos
*pos
;
1855 int charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
1856 int i
, overlay_strings_with_newlines
= 0;
1858 /* If POS specifies a position in a display vector, this might
1859 be for an ellipsis displayed for invisible text. We won't
1860 get the iterator set up for delivering that ellipsis unless
1861 we make sure that it gets aware of the invisible text. */
1862 if (in_ellipses_for_invisible_text_p (pos
, w
))
1868 /* Keep in mind: the call to reseat in init_iterator skips invisible
1869 text, so we might end up at a position different from POS. This
1870 is only a problem when POS is a row start after a newline and an
1871 overlay starts there with an after-string, and the overlay has an
1872 invisible property. Since we don't skip invisible text in
1873 display_line and elsewhere immediately after consuming the
1874 newline before the row start, such a POS will not be in a string,
1875 but the call to init_iterator below will move us to the
1877 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
1879 for (i
= 0; i
< it
->n_overlay_strings
; ++i
)
1881 const char *s
= SDATA (it
->overlay_strings
[i
]);
1882 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
1884 while (s
< e
&& *s
!= '\n')
1889 overlay_strings_with_newlines
= 1;
1894 /* If position is within an overlay string, set up IT to the right
1896 if (pos
->overlay_string_index
>= 0)
1900 /* If the first overlay string happens to have a `display'
1901 property for an image, the iterator will be set up for that
1902 image, and we have to undo that setup first before we can
1903 correct the overlay string index. */
1904 if (it
->method
== next_element_from_image
)
1907 /* We already have the first chunk of overlay strings in
1908 IT->overlay_strings. Load more until the one for
1909 pos->overlay_string_index is in IT->overlay_strings. */
1910 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
1912 int n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
1913 it
->current
.overlay_string_index
= 0;
1916 load_overlay_strings (it
, 0);
1917 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
1921 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
1922 relative_index
= (it
->current
.overlay_string_index
1923 % OVERLAY_STRING_CHUNK_SIZE
);
1924 it
->string
= it
->overlay_strings
[relative_index
];
1925 xassert (STRINGP (it
->string
));
1926 it
->current
.string_pos
= pos
->string_pos
;
1927 it
->method
= next_element_from_string
;
1930 #if 0 /* This is bogus because POS not having an overlay string
1931 position does not mean it's after the string. Example: A
1932 line starting with a before-string and initialization of IT
1933 to the previous row's end position. */
1934 else if (it
->current
.overlay_string_index
>= 0)
1936 /* If POS says we're already after an overlay string ending at
1937 POS, make sure to pop the iterator because it will be in
1938 front of that overlay string. When POS is ZV, we've thereby
1939 also ``processed'' overlay strings at ZV. */
1942 it
->current
.overlay_string_index
= -1;
1943 it
->method
= next_element_from_buffer
;
1944 if (CHARPOS (pos
->pos
) == ZV
)
1945 it
->overlay_strings_at_end_processed_p
= 1;
1949 if (CHARPOS (pos
->string_pos
) >= 0)
1951 /* Recorded position is not in an overlay string, but in another
1952 string. This can only be a string from a `display' property.
1953 IT should already be filled with that string. */
1954 it
->current
.string_pos
= pos
->string_pos
;
1955 xassert (STRINGP (it
->string
));
1958 /* Restore position in display vector translations, control
1959 character translations or ellipses. */
1960 if (pos
->dpvec_index
>= 0)
1962 if (it
->dpvec
== NULL
)
1963 get_next_display_element (it
);
1964 xassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
1965 it
->current
.dpvec_index
= pos
->dpvec_index
;
1969 return !overlay_strings_with_newlines
;
1973 /* Initialize IT for stepping through current_buffer in window W
1974 starting at ROW->start. */
1977 init_to_row_start (it
, w
, row
)
1980 struct glyph_row
*row
;
1982 init_from_display_pos (it
, w
, &row
->start
);
1983 it
->continuation_lines_width
= row
->continuation_lines_width
;
1988 /* Initialize IT for stepping through current_buffer in window W
1989 starting in the line following ROW, i.e. starting at ROW->end.
1990 Value is zero if there are overlay strings with newlines at ROW's
1994 init_to_row_end (it
, w
, row
)
1997 struct glyph_row
*row
;
2001 if (init_from_display_pos (it
, w
, &row
->end
))
2003 if (row
->continued_p
)
2004 it
->continuation_lines_width
2005 = row
->continuation_lines_width
+ row
->pixel_width
;
2016 /***********************************************************************
2018 ***********************************************************************/
2020 /* Called when IT reaches IT->stop_charpos. Handle text property and
2021 overlay changes. Set IT->stop_charpos to the next position where
2028 enum prop_handled handled
;
2029 int handle_overlay_change_p
= 1;
2033 it
->current
.dpvec_index
= -1;
2037 handled
= HANDLED_NORMALLY
;
2039 /* Call text property handlers. */
2040 for (p
= it_props
; p
->handler
; ++p
)
2042 handled
= p
->handler (it
);
2044 if (handled
== HANDLED_RECOMPUTE_PROPS
)
2046 else if (handled
== HANDLED_RETURN
)
2048 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
2049 handle_overlay_change_p
= 0;
2052 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
2054 /* Don't check for overlay strings below when set to deliver
2055 characters from a display vector. */
2056 if (it
->method
== next_element_from_display_vector
)
2057 handle_overlay_change_p
= 0;
2059 /* Handle overlay changes. */
2060 if (handle_overlay_change_p
)
2061 handled
= handle_overlay_change (it
);
2063 /* Determine where to stop next. */
2064 if (handled
== HANDLED_NORMALLY
)
2065 compute_stop_pos (it
);
2068 while (handled
== HANDLED_RECOMPUTE_PROPS
);
2072 /* Compute IT->stop_charpos from text property and overlay change
2073 information for IT's current position. */
2076 compute_stop_pos (it
)
2079 register INTERVAL iv
, next_iv
;
2080 Lisp_Object object
, limit
, position
;
2082 /* If nowhere else, stop at the end. */
2083 it
->stop_charpos
= it
->end_charpos
;
2085 if (STRINGP (it
->string
))
2087 /* Strings are usually short, so don't limit the search for
2089 object
= it
->string
;
2091 position
= make_number (IT_STRING_CHARPOS (*it
));
2097 /* If next overlay change is in front of the current stop pos
2098 (which is IT->end_charpos), stop there. Note: value of
2099 next_overlay_change is point-max if no overlay change
2101 charpos
= next_overlay_change (IT_CHARPOS (*it
));
2102 if (charpos
< it
->stop_charpos
)
2103 it
->stop_charpos
= charpos
;
2105 /* If showing the region, we have to stop at the region
2106 start or end because the face might change there. */
2107 if (it
->region_beg_charpos
> 0)
2109 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
2110 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
2111 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
2112 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
2115 /* Set up variables for computing the stop position from text
2116 property changes. */
2117 XSETBUFFER (object
, current_buffer
);
2118 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
2119 position
= make_number (IT_CHARPOS (*it
));
2123 /* Get the interval containing IT's position. Value is a null
2124 interval if there isn't such an interval. */
2125 iv
= validate_interval_range (object
, &position
, &position
, 0);
2126 if (!NULL_INTERVAL_P (iv
))
2128 Lisp_Object values_here
[LAST_PROP_IDX
];
2131 /* Get properties here. */
2132 for (p
= it_props
; p
->handler
; ++p
)
2133 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
2135 /* Look for an interval following iv that has different
2137 for (next_iv
= next_interval (iv
);
2138 (!NULL_INTERVAL_P (next_iv
)
2140 || XFASTINT (limit
) > next_iv
->position
));
2141 next_iv
= next_interval (next_iv
))
2143 for (p
= it_props
; p
->handler
; ++p
)
2145 Lisp_Object new_value
;
2147 new_value
= textget (next_iv
->plist
, *p
->name
);
2148 if (!EQ (values_here
[p
->idx
], new_value
))
2156 if (!NULL_INTERVAL_P (next_iv
))
2158 if (INTEGERP (limit
)
2159 && next_iv
->position
>= XFASTINT (limit
))
2160 /* No text property change up to limit. */
2161 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
2163 /* Text properties change in next_iv. */
2164 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
2168 xassert (STRINGP (it
->string
)
2169 || (it
->stop_charpos
>= BEGV
2170 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
2174 /* Return the position of the next overlay change after POS in
2175 current_buffer. Value is point-max if no overlay change
2176 follows. This is like `next-overlay-change' but doesn't use
2180 next_overlay_change (pos
)
2185 Lisp_Object
*overlays
;
2189 /* Get all overlays at the given position. */
2191 overlays
= (Lisp_Object
*) alloca (len
* sizeof *overlays
);
2192 noverlays
= overlays_at (pos
, 0, &overlays
, &len
, &endpos
, NULL
, 1);
2193 if (noverlays
> len
)
2196 overlays
= (Lisp_Object
*) alloca (len
* sizeof *overlays
);
2197 noverlays
= overlays_at (pos
, 0, &overlays
, &len
, &endpos
, NULL
, 1);
2200 /* If any of these overlays ends before endpos,
2201 use its ending point instead. */
2202 for (i
= 0; i
< noverlays
; ++i
)
2207 oend
= OVERLAY_END (overlays
[i
]);
2208 oendpos
= OVERLAY_POSITION (oend
);
2209 endpos
= min (endpos
, oendpos
);
2217 /***********************************************************************
2219 ***********************************************************************/
2221 /* Handle changes in the `fontified' property of the current buffer by
2222 calling hook functions from Qfontification_functions to fontify
2225 static enum prop_handled
2226 handle_fontified_prop (it
)
2229 Lisp_Object prop
, pos
;
2230 enum prop_handled handled
= HANDLED_NORMALLY
;
2232 /* Get the value of the `fontified' property at IT's current buffer
2233 position. (The `fontified' property doesn't have a special
2234 meaning in strings.) If the value is nil, call functions from
2235 Qfontification_functions. */
2236 if (!STRINGP (it
->string
)
2238 && !NILP (Vfontification_functions
)
2239 && !NILP (Vrun_hooks
)
2240 && (pos
= make_number (IT_CHARPOS (*it
)),
2241 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
2244 int count
= SPECPDL_INDEX ();
2247 val
= Vfontification_functions
;
2248 specbind (Qfontification_functions
, Qnil
);
2250 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
2251 safe_call1 (val
, pos
);
2254 Lisp_Object globals
, fn
;
2255 struct gcpro gcpro1
, gcpro2
;
2258 GCPRO2 (val
, globals
);
2260 for (; CONSP (val
); val
= XCDR (val
))
2266 /* A value of t indicates this hook has a local
2267 binding; it means to run the global binding too.
2268 In a global value, t should not occur. If it
2269 does, we must ignore it to avoid an endless
2271 for (globals
= Fdefault_value (Qfontification_functions
);
2273 globals
= XCDR (globals
))
2275 fn
= XCAR (globals
);
2277 safe_call1 (fn
, pos
);
2281 safe_call1 (fn
, pos
);
2287 unbind_to (count
, Qnil
);
2289 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
2290 something. This avoids an endless loop if they failed to
2291 fontify the text for which reason ever. */
2292 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
2293 handled
= HANDLED_RECOMPUTE_PROPS
;
2301 /***********************************************************************
2303 ***********************************************************************/
2305 /* Set up iterator IT from face properties at its current position.
2306 Called from handle_stop. */
2308 static enum prop_handled
2309 handle_face_prop (it
)
2312 int new_face_id
, next_stop
;
2314 if (!STRINGP (it
->string
))
2317 = face_at_buffer_position (it
->w
,
2319 it
->region_beg_charpos
,
2320 it
->region_end_charpos
,
2323 + TEXT_PROP_DISTANCE_LIMIT
),
2326 /* Is this a start of a run of characters with box face?
2327 Caveat: this can be called for a freshly initialized
2328 iterator; face_id is -1 in this case. We know that the new
2329 face will not change until limit, i.e. if the new face has a
2330 box, all characters up to limit will have one. But, as
2331 usual, we don't know whether limit is really the end. */
2332 if (new_face_id
!= it
->face_id
)
2334 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
2336 /* If new face has a box but old face has not, this is
2337 the start of a run of characters with box, i.e. it has
2338 a shadow on the left side. The value of face_id of the
2339 iterator will be -1 if this is the initial call that gets
2340 the face. In this case, we have to look in front of IT's
2341 position and see whether there is a face != new_face_id. */
2342 it
->start_of_box_run_p
2343 = (new_face
->box
!= FACE_NO_BOX
2344 && (it
->face_id
>= 0
2345 || IT_CHARPOS (*it
) == BEG
2346 || new_face_id
!= face_before_it_pos (it
)));
2347 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
2352 int base_face_id
, bufpos
;
2354 if (it
->current
.overlay_string_index
>= 0)
2355 bufpos
= IT_CHARPOS (*it
);
2359 /* For strings from a buffer, i.e. overlay strings or strings
2360 from a `display' property, use the face at IT's current
2361 buffer position as the base face to merge with, so that
2362 overlay strings appear in the same face as surrounding
2363 text, unless they specify their own faces. */
2364 base_face_id
= underlying_face_id (it
);
2366 new_face_id
= face_at_string_position (it
->w
,
2368 IT_STRING_CHARPOS (*it
),
2370 it
->region_beg_charpos
,
2371 it
->region_end_charpos
,
2375 #if 0 /* This shouldn't be neccessary. Let's check it. */
2376 /* If IT is used to display a mode line we would really like to
2377 use the mode line face instead of the frame's default face. */
2378 if (it
->glyph_row
== MATRIX_MODE_LINE_ROW (it
->w
->desired_matrix
)
2379 && new_face_id
== DEFAULT_FACE_ID
)
2380 new_face_id
= CURRENT_MODE_LINE_FACE_ID (it
->w
);
2383 /* Is this a start of a run of characters with box? Caveat:
2384 this can be called for a freshly allocated iterator; face_id
2385 is -1 is this case. We know that the new face will not
2386 change until the next check pos, i.e. if the new face has a
2387 box, all characters up to that position will have a
2388 box. But, as usual, we don't know whether that position
2389 is really the end. */
2390 if (new_face_id
!= it
->face_id
)
2392 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
2393 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2395 /* If new face has a box but old face hasn't, this is the
2396 start of a run of characters with box, i.e. it has a
2397 shadow on the left side. */
2398 it
->start_of_box_run_p
2399 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
2400 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
2404 it
->face_id
= new_face_id
;
2405 return HANDLED_NORMALLY
;
2409 /* Return the ID of the face ``underlying'' IT's current position,
2410 which is in a string. If the iterator is associated with a
2411 buffer, return the face at IT's current buffer position.
2412 Otherwise, use the iterator's base_face_id. */
2415 underlying_face_id (it
)
2418 int face_id
= it
->base_face_id
, i
;
2420 xassert (STRINGP (it
->string
));
2422 for (i
= it
->sp
- 1; i
>= 0; --i
)
2423 if (NILP (it
->stack
[i
].string
))
2424 face_id
= it
->stack
[i
].face_id
;
2430 /* Compute the face one character before or after the current position
2431 of IT. BEFORE_P non-zero means get the face in front of IT's
2432 position. Value is the id of the face. */
2435 face_before_or_after_it_pos (it
, before_p
)
2440 int next_check_charpos
;
2441 struct text_pos pos
;
2443 xassert (it
->s
== NULL
);
2445 if (STRINGP (it
->string
))
2447 int bufpos
, base_face_id
;
2449 /* No face change past the end of the string (for the case
2450 we are padding with spaces). No face change before the
2452 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
2453 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
2456 /* Set pos to the position before or after IT's current position. */
2458 pos
= string_pos (IT_STRING_CHARPOS (*it
) - 1, it
->string
);
2460 /* For composition, we must check the character after the
2462 pos
= (it
->what
== IT_COMPOSITION
2463 ? string_pos (IT_STRING_CHARPOS (*it
) + it
->cmp_len
, it
->string
)
2464 : string_pos (IT_STRING_CHARPOS (*it
) + 1, it
->string
));
2466 if (it
->current
.overlay_string_index
>= 0)
2467 bufpos
= IT_CHARPOS (*it
);
2471 base_face_id
= underlying_face_id (it
);
2473 /* Get the face for ASCII, or unibyte. */
2474 face_id
= face_at_string_position (it
->w
,
2478 it
->region_beg_charpos
,
2479 it
->region_end_charpos
,
2480 &next_check_charpos
,
2483 /* Correct the face for charsets different from ASCII. Do it
2484 for the multibyte case only. The face returned above is
2485 suitable for unibyte text if IT->string is unibyte. */
2486 if (STRING_MULTIBYTE (it
->string
))
2488 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos
);
2489 int rest
= SBYTES (it
->string
) - BYTEPOS (pos
);
2491 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
2493 c
= string_char_and_length (p
, rest
, &len
);
2494 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
);
2499 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
2500 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
2503 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
2504 pos
= it
->current
.pos
;
2507 DEC_TEXT_POS (pos
, it
->multibyte_p
);
2510 if (it
->what
== IT_COMPOSITION
)
2511 /* For composition, we must check the position after the
2513 pos
.charpos
+= it
->cmp_len
, pos
.bytepos
+= it
->len
;
2515 INC_TEXT_POS (pos
, it
->multibyte_p
);
2518 /* Determine face for CHARSET_ASCII, or unibyte. */
2519 face_id
= face_at_buffer_position (it
->w
,
2521 it
->region_beg_charpos
,
2522 it
->region_end_charpos
,
2523 &next_check_charpos
,
2526 /* Correct the face for charsets different from ASCII. Do it
2527 for the multibyte case only. The face returned above is
2528 suitable for unibyte text if current_buffer is unibyte. */
2529 if (it
->multibyte_p
)
2531 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
2532 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
2533 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
);
2542 /***********************************************************************
2544 ***********************************************************************/
2546 /* Set up iterator IT from invisible properties at its current
2547 position. Called from handle_stop. */
2549 static enum prop_handled
2550 handle_invisible_prop (it
)
2553 enum prop_handled handled
= HANDLED_NORMALLY
;
2555 if (STRINGP (it
->string
))
2557 extern Lisp_Object Qinvisible
;
2558 Lisp_Object prop
, end_charpos
, limit
, charpos
;
2560 /* Get the value of the invisible text property at the
2561 current position. Value will be nil if there is no such
2563 charpos
= make_number (IT_STRING_CHARPOS (*it
));
2564 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
2567 && IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
2569 handled
= HANDLED_RECOMPUTE_PROPS
;
2571 /* Get the position at which the next change of the
2572 invisible text property can be found in IT->string.
2573 Value will be nil if the property value is the same for
2574 all the rest of IT->string. */
2575 XSETINT (limit
, SCHARS (it
->string
));
2576 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
2579 /* Text at current position is invisible. The next
2580 change in the property is at position end_charpos.
2581 Move IT's current position to that position. */
2582 if (INTEGERP (end_charpos
)
2583 && XFASTINT (end_charpos
) < XFASTINT (limit
))
2585 struct text_pos old
;
2586 old
= it
->current
.string_pos
;
2587 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
2588 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
2592 /* The rest of the string is invisible. If this is an
2593 overlay string, proceed with the next overlay string
2594 or whatever comes and return a character from there. */
2595 if (it
->current
.overlay_string_index
>= 0)
2597 next_overlay_string (it
);
2598 /* Don't check for overlay strings when we just
2599 finished processing them. */
2600 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
2604 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
2605 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
2612 int invis_p
, newpos
, next_stop
, start_charpos
;
2613 Lisp_Object pos
, prop
, overlay
;
2615 /* First of all, is there invisible text at this position? */
2616 start_charpos
= IT_CHARPOS (*it
);
2617 pos
= make_number (IT_CHARPOS (*it
));
2618 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
2620 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
2622 /* If we are on invisible text, skip over it. */
2623 if (invis_p
&& IT_CHARPOS (*it
) < it
->end_charpos
)
2625 /* Record whether we have to display an ellipsis for the
2627 int display_ellipsis_p
= invis_p
== 2;
2629 handled
= HANDLED_RECOMPUTE_PROPS
;
2631 /* Loop skipping over invisible text. The loop is left at
2632 ZV or with IT on the first char being visible again. */
2635 /* Try to skip some invisible text. Return value is the
2636 position reached which can be equal to IT's position
2637 if there is nothing invisible here. This skips both
2638 over invisible text properties and overlays with
2639 invisible property. */
2640 newpos
= skip_invisible (IT_CHARPOS (*it
),
2641 &next_stop
, ZV
, it
->window
);
2643 /* If we skipped nothing at all we weren't at invisible
2644 text in the first place. If everything to the end of
2645 the buffer was skipped, end the loop. */
2646 if (newpos
== IT_CHARPOS (*it
) || newpos
>= ZV
)
2650 /* We skipped some characters but not necessarily
2651 all there are. Check if we ended up on visible
2652 text. Fget_char_property returns the property of
2653 the char before the given position, i.e. if we
2654 get invis_p = 0, this means that the char at
2655 newpos is visible. */
2656 pos
= make_number (newpos
);
2657 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
2658 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
2661 /* If we ended up on invisible text, proceed to
2662 skip starting with next_stop. */
2664 IT_CHARPOS (*it
) = next_stop
;
2668 /* The position newpos is now either ZV or on visible text. */
2669 IT_CHARPOS (*it
) = newpos
;
2670 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
2672 /* If there are before-strings at the start of invisible
2673 text, and the text is invisible because of a text
2674 property, arrange to show before-strings because 20.x did
2675 it that way. (If the text is invisible because of an
2676 overlay property instead of a text property, this is
2677 already handled in the overlay code.) */
2679 && get_overlay_strings (it
, start_charpos
))
2681 handled
= HANDLED_RECOMPUTE_PROPS
;
2682 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
2684 else if (display_ellipsis_p
)
2685 setup_for_ellipsis (it
);
2693 /* Make iterator IT return `...' next. */
2696 setup_for_ellipsis (it
)
2700 && VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
2702 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
2703 it
->dpvec
= v
->contents
;
2704 it
->dpend
= v
->contents
+ v
->size
;
2708 /* Default `...'. */
2709 it
->dpvec
= default_invis_vector
;
2710 it
->dpend
= default_invis_vector
+ 3;
2713 /* The ellipsis display does not replace the display of the
2714 character at the new position. Indicate this by setting
2715 IT->dpvec_char_len to zero. */
2716 it
->dpvec_char_len
= 0;
2718 it
->current
.dpvec_index
= 0;
2719 it
->method
= next_element_from_display_vector
;
2724 /***********************************************************************
2726 ***********************************************************************/
2728 /* Set up iterator IT from `display' property at its current position.
2729 Called from handle_stop. */
2731 static enum prop_handled
2732 handle_display_prop (it
)
2735 Lisp_Object prop
, object
;
2736 struct text_pos
*position
;
2737 int display_replaced_p
= 0;
2739 if (STRINGP (it
->string
))
2741 object
= it
->string
;
2742 position
= &it
->current
.string_pos
;
2746 object
= it
->w
->buffer
;
2747 position
= &it
->current
.pos
;
2750 /* Reset those iterator values set from display property values. */
2751 it
->font_height
= Qnil
;
2752 it
->space_width
= Qnil
;
2755 /* We don't support recursive `display' properties, i.e. string
2756 values that have a string `display' property, that have a string
2757 `display' property etc. */
2758 if (!it
->string_from_display_prop_p
)
2759 it
->area
= TEXT_AREA
;
2761 prop
= Fget_char_property (make_number (position
->charpos
),
2764 return HANDLED_NORMALLY
;
2767 /* Simple properties. */
2768 && !EQ (XCAR (prop
), Qimage
)
2769 && !EQ (XCAR (prop
), Qspace
)
2770 && !EQ (XCAR (prop
), Qwhen
)
2771 && !EQ (XCAR (prop
), Qspace_width
)
2772 && !EQ (XCAR (prop
), Qheight
)
2773 && !EQ (XCAR (prop
), Qraise
)
2774 /* Marginal area specifications. */
2775 && !(CONSP (XCAR (prop
)) && EQ (XCAR (XCAR (prop
)), Qmargin
))
2776 && !NILP (XCAR (prop
)))
2778 for (; CONSP (prop
); prop
= XCDR (prop
))
2780 if (handle_single_display_prop (it
, XCAR (prop
), object
,
2781 position
, display_replaced_p
))
2782 display_replaced_p
= 1;
2785 else if (VECTORP (prop
))
2788 for (i
= 0; i
< ASIZE (prop
); ++i
)
2789 if (handle_single_display_prop (it
, AREF (prop
, i
), object
,
2790 position
, display_replaced_p
))
2791 display_replaced_p
= 1;
2795 if (handle_single_display_prop (it
, prop
, object
, position
, 0))
2796 display_replaced_p
= 1;
2799 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
2803 /* Value is the position of the end of the `display' property starting
2804 at START_POS in OBJECT. */
2806 static struct text_pos
2807 display_prop_end (it
, object
, start_pos
)
2810 struct text_pos start_pos
;
2813 struct text_pos end_pos
;
2815 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
2816 Qdisplay
, object
, Qnil
);
2817 CHARPOS (end_pos
) = XFASTINT (end
);
2818 if (STRINGP (object
))
2819 compute_string_pos (&end_pos
, start_pos
, it
->string
);
2821 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
2827 /* Set up IT from a single `display' sub-property value PROP. OBJECT
2828 is the object in which the `display' property was found. *POSITION
2829 is the position at which it was found. DISPLAY_REPLACED_P non-zero
2830 means that we previously saw a display sub-property which already
2831 replaced text display with something else, for example an image;
2832 ignore such properties after the first one has been processed.
2834 If PROP is a `space' or `image' sub-property, set *POSITION to the
2835 end position of the `display' property.
2837 Value is non-zero if something was found which replaces the display
2838 of buffer or string text. */
2841 handle_single_display_prop (it
, prop
, object
, position
,
2842 display_replaced_before_p
)
2846 struct text_pos
*position
;
2847 int display_replaced_before_p
;
2850 int replaces_text_display_p
= 0;
2853 /* If PROP is a list of the form `(when FORM . VALUE)', FORM is
2854 evaluated. If the result is nil, VALUE is ignored. */
2856 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
2865 if (!NILP (form
) && !EQ (form
, Qt
))
2867 int count
= SPECPDL_INDEX ();
2868 struct gcpro gcpro1
;
2870 /* Bind `object' to the object having the `display' property, a
2871 buffer or string. Bind `position' to the position in the
2872 object where the property was found, and `buffer-position'
2873 to the current position in the buffer. */
2874 specbind (Qobject
, object
);
2875 specbind (Qposition
, make_number (CHARPOS (*position
)));
2876 specbind (Qbuffer_position
,
2877 make_number (STRINGP (object
)
2878 ? IT_CHARPOS (*it
) : CHARPOS (*position
)));
2880 form
= safe_eval (form
);
2882 unbind_to (count
, Qnil
);
2889 && EQ (XCAR (prop
), Qheight
)
2890 && CONSP (XCDR (prop
)))
2892 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2895 /* `(height HEIGHT)'. */
2896 it
->font_height
= XCAR (XCDR (prop
));
2897 if (!NILP (it
->font_height
))
2899 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2900 int new_height
= -1;
2902 if (CONSP (it
->font_height
)
2903 && (EQ (XCAR (it
->font_height
), Qplus
)
2904 || EQ (XCAR (it
->font_height
), Qminus
))
2905 && CONSP (XCDR (it
->font_height
))
2906 && INTEGERP (XCAR (XCDR (it
->font_height
))))
2908 /* `(+ N)' or `(- N)' where N is an integer. */
2909 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
2910 if (EQ (XCAR (it
->font_height
), Qplus
))
2912 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
2914 else if (FUNCTIONP (it
->font_height
))
2916 /* Call function with current height as argument.
2917 Value is the new height. */
2919 height
= safe_call1 (it
->font_height
,
2920 face
->lface
[LFACE_HEIGHT_INDEX
]);
2921 if (NUMBERP (height
))
2922 new_height
= XFLOATINT (height
);
2924 else if (NUMBERP (it
->font_height
))
2926 /* Value is a multiple of the canonical char height. */
2929 face
= FACE_FROM_ID (it
->f
, DEFAULT_FACE_ID
);
2930 new_height
= (XFLOATINT (it
->font_height
)
2931 * XINT (face
->lface
[LFACE_HEIGHT_INDEX
]));
2935 /* Evaluate IT->font_height with `height' bound to the
2936 current specified height to get the new height. */
2938 int count
= SPECPDL_INDEX ();
2940 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
2941 value
= safe_eval (it
->font_height
);
2942 unbind_to (count
, Qnil
);
2944 if (NUMBERP (value
))
2945 new_height
= XFLOATINT (value
);
2949 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
2952 else if (CONSP (prop
)
2953 && EQ (XCAR (prop
), Qspace_width
)
2954 && CONSP (XCDR (prop
)))
2956 /* `(space_width WIDTH)'. */
2957 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2960 value
= XCAR (XCDR (prop
));
2961 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
2962 it
->space_width
= value
;
2964 else if (CONSP (prop
)
2965 && EQ (XCAR (prop
), Qraise
)
2966 && CONSP (XCDR (prop
)))
2968 /* `(raise FACTOR)'. */
2969 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2972 #ifdef HAVE_WINDOW_SYSTEM
2973 value
= XCAR (XCDR (prop
));
2974 if (NUMBERP (value
))
2976 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2977 it
->voffset
= - (XFLOATINT (value
)
2978 * (FONT_HEIGHT (face
->font
)));
2980 #endif /* HAVE_WINDOW_SYSTEM */
2982 else if (!it
->string_from_display_prop_p
)
2984 /* `((margin left-margin) VALUE)' or `((margin right-margin)
2985 VALUE) or `((margin nil) VALUE)' or VALUE. */
2986 Lisp_Object location
, value
;
2987 struct text_pos start_pos
;
2990 /* Characters having this form of property are not displayed, so
2991 we have to find the end of the property. */
2992 start_pos
= *position
;
2993 *position
= display_prop_end (it
, object
, start_pos
);
2996 /* Let's stop at the new position and assume that all
2997 text properties change there. */
2998 it
->stop_charpos
= position
->charpos
;
3000 location
= Qunbound
;
3001 if (CONSP (prop
) && CONSP (XCAR (prop
)))
3005 value
= XCDR (prop
);
3007 value
= XCAR (value
);
3010 if (EQ (XCAR (tem
), Qmargin
)
3011 && (tem
= XCDR (tem
),
3012 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
3014 || EQ (tem
, Qleft_margin
)
3015 || EQ (tem
, Qright_margin
))))
3019 if (EQ (location
, Qunbound
))
3025 #ifdef HAVE_WINDOW_SYSTEM
3026 if (FRAME_TERMCAP_P (it
->f
))
3027 valid_p
= STRINGP (value
);
3029 valid_p
= (STRINGP (value
)
3030 || (CONSP (value
) && EQ (XCAR (value
), Qspace
))
3031 || valid_image_p (value
));
3032 #else /* not HAVE_WINDOW_SYSTEM */
3033 valid_p
= STRINGP (value
);
3034 #endif /* not HAVE_WINDOW_SYSTEM */
3036 if ((EQ (location
, Qleft_margin
)
3037 || EQ (location
, Qright_margin
)
3040 && !display_replaced_before_p
)
3042 replaces_text_display_p
= 1;
3044 /* Save current settings of IT so that we can restore them
3045 when we are finished with the glyph property value. */
3048 if (NILP (location
))
3049 it
->area
= TEXT_AREA
;
3050 else if (EQ (location
, Qleft_margin
))
3051 it
->area
= LEFT_MARGIN_AREA
;
3053 it
->area
= RIGHT_MARGIN_AREA
;
3055 if (STRINGP (value
))
3058 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
3059 it
->current
.overlay_string_index
= -1;
3060 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
3061 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
3062 it
->method
= next_element_from_string
;
3063 it
->stop_charpos
= 0;
3064 it
->string_from_display_prop_p
= 1;
3065 /* Say that we haven't consumed the characters with
3066 `display' property yet. The call to pop_it in
3067 set_iterator_to_next will clean this up. */
3068 *position
= start_pos
;
3070 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
3072 it
->method
= next_element_from_stretch
;
3074 it
->current
.pos
= it
->position
= start_pos
;
3076 #ifdef HAVE_WINDOW_SYSTEM
3079 it
->what
= IT_IMAGE
;
3080 it
->image_id
= lookup_image (it
->f
, value
);
3081 it
->position
= start_pos
;
3082 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
3083 it
->method
= next_element_from_image
;
3085 /* Say that we haven't consumed the characters with
3086 `display' property yet. The call to pop_it in
3087 set_iterator_to_next will clean this up. */
3088 *position
= start_pos
;
3090 #endif /* HAVE_WINDOW_SYSTEM */
3093 /* Invalid property or property not supported. Restore
3094 the position to what it was before. */
3095 *position
= start_pos
;
3098 return replaces_text_display_p
;
3102 /* Check if PROP is a display sub-property value whose text should be
3103 treated as intangible. */
3106 single_display_prop_intangible_p (prop
)
3109 /* Skip over `when FORM'. */
3110 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
3121 /* Skip over `margin LOCATION'. If LOCATION is in the margins,
3122 we don't need to treat text as intangible. */
3123 if (EQ (XCAR (prop
), Qmargin
))
3131 || EQ (XCAR (prop
), Qleft_margin
)
3132 || EQ (XCAR (prop
), Qright_margin
))
3136 return CONSP (prop
) && EQ (XCAR (prop
), Qimage
);
3140 /* Check if PROP is a display property value whose text should be
3141 treated as intangible. */
3144 display_prop_intangible_p (prop
)
3148 && CONSP (XCAR (prop
))
3149 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
3151 /* A list of sub-properties. */
3152 while (CONSP (prop
))
3154 if (single_display_prop_intangible_p (XCAR (prop
)))
3159 else if (VECTORP (prop
))
3161 /* A vector of sub-properties. */
3163 for (i
= 0; i
< ASIZE (prop
); ++i
)
3164 if (single_display_prop_intangible_p (AREF (prop
, i
)))
3168 return single_display_prop_intangible_p (prop
);
3174 /* Return 1 if PROP is a display sub-property value containing STRING. */
3177 single_display_prop_string_p (prop
, string
)
3178 Lisp_Object prop
, string
;
3180 if (EQ (string
, prop
))
3183 /* Skip over `when FORM'. */
3184 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
3193 /* Skip over `margin LOCATION'. */
3194 if (EQ (XCAR (prop
), Qmargin
))
3205 return CONSP (prop
) && EQ (XCAR (prop
), string
);
3209 /* Return 1 if STRING appears in the `display' property PROP. */
3212 display_prop_string_p (prop
, string
)
3213 Lisp_Object prop
, string
;
3216 && CONSP (XCAR (prop
))
3217 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
3219 /* A list of sub-properties. */
3220 while (CONSP (prop
))
3222 if (single_display_prop_string_p (XCAR (prop
), string
))
3227 else if (VECTORP (prop
))
3229 /* A vector of sub-properties. */
3231 for (i
= 0; i
< ASIZE (prop
); ++i
)
3232 if (single_display_prop_string_p (AREF (prop
, i
), string
))
3236 return single_display_prop_string_p (prop
, string
);
3242 /* Determine from which buffer position in W's buffer STRING comes
3243 from. AROUND_CHARPOS is an approximate position where it could
3244 be from. Value is the buffer position or 0 if it couldn't be
3247 W's buffer must be current.
3249 This function is necessary because we don't record buffer positions
3250 in glyphs generated from strings (to keep struct glyph small).
3251 This function may only use code that doesn't eval because it is
3252 called asynchronously from note_mouse_highlight. */
3255 string_buffer_position (w
, string
, around_charpos
)
3260 Lisp_Object limit
, prop
, pos
;
3261 const int MAX_DISTANCE
= 1000;
3264 pos
= make_number (around_charpos
);
3265 limit
= make_number (min (XINT (pos
) + MAX_DISTANCE
, ZV
));
3266 while (!found
&& !EQ (pos
, limit
))
3268 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
3269 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
3272 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
, limit
);
3277 pos
= make_number (around_charpos
);
3278 limit
= make_number (max (XINT (pos
) - MAX_DISTANCE
, BEGV
));
3279 while (!found
&& !EQ (pos
, limit
))
3281 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
3282 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
3285 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
3290 return found
? XINT (pos
) : 0;
3295 /***********************************************************************
3296 `composition' property
3297 ***********************************************************************/
3299 /* Set up iterator IT from `composition' property at its current
3300 position. Called from handle_stop. */
3302 static enum prop_handled
3303 handle_composition_prop (it
)
3306 Lisp_Object prop
, string
;
3307 int pos
, pos_byte
, end
;
3308 enum prop_handled handled
= HANDLED_NORMALLY
;
3310 if (STRINGP (it
->string
))
3312 pos
= IT_STRING_CHARPOS (*it
);
3313 pos_byte
= IT_STRING_BYTEPOS (*it
);
3314 string
= it
->string
;
3318 pos
= IT_CHARPOS (*it
);
3319 pos_byte
= IT_BYTEPOS (*it
);
3323 /* If there's a valid composition and point is not inside of the
3324 composition (in the case that the composition is from the current
3325 buffer), draw a glyph composed from the composition components. */
3326 if (find_composition (pos
, -1, &pos
, &end
, &prop
, string
)
3327 && COMPOSITION_VALID_P (pos
, end
, prop
)
3328 && (STRINGP (it
->string
) || (PT
<= pos
|| PT
>= end
)))
3330 int id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, string
);
3334 it
->method
= next_element_from_composition
;
3336 it
->cmp_len
= COMPOSITION_LENGTH (prop
);
3337 /* For a terminal, draw only the first character of the
3339 it
->c
= COMPOSITION_GLYPH (composition_table
[id
], 0);
3340 it
->len
= (STRINGP (it
->string
)
3341 ? string_char_to_byte (it
->string
, end
)
3342 : CHAR_TO_BYTE (end
)) - pos_byte
;
3343 it
->stop_charpos
= end
;
3344 handled
= HANDLED_RETURN
;
3353 /***********************************************************************
3355 ***********************************************************************/
3357 /* The following structure is used to record overlay strings for
3358 later sorting in load_overlay_strings. */
3360 struct overlay_entry
3362 Lisp_Object overlay
;
3369 /* Set up iterator IT from overlay strings at its current position.
3370 Called from handle_stop. */
3372 static enum prop_handled
3373 handle_overlay_change (it
)
3376 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
3377 return HANDLED_RECOMPUTE_PROPS
;
3379 return HANDLED_NORMALLY
;
3383 /* Set up the next overlay string for delivery by IT, if there is an
3384 overlay string to deliver. Called by set_iterator_to_next when the
3385 end of the current overlay string is reached. If there are more
3386 overlay strings to display, IT->string and
3387 IT->current.overlay_string_index are set appropriately here.
3388 Otherwise IT->string is set to nil. */
3391 next_overlay_string (it
)
3394 ++it
->current
.overlay_string_index
;
3395 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
3397 /* No more overlay strings. Restore IT's settings to what
3398 they were before overlay strings were processed, and
3399 continue to deliver from current_buffer. */
3400 int display_ellipsis_p
= it
->stack
[it
->sp
- 1].display_ellipsis_p
;
3403 xassert (it
->stop_charpos
>= BEGV
3404 && it
->stop_charpos
<= it
->end_charpos
);
3406 it
->current
.overlay_string_index
= -1;
3407 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
3408 it
->n_overlay_strings
= 0;
3409 it
->method
= next_element_from_buffer
;
3411 /* If we're at the end of the buffer, record that we have
3412 processed the overlay strings there already, so that
3413 next_element_from_buffer doesn't try it again. */
3414 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
3415 it
->overlay_strings_at_end_processed_p
= 1;
3417 /* If we have to display `...' for invisible text, set
3418 the iterator up for that. */
3419 if (display_ellipsis_p
)
3420 setup_for_ellipsis (it
);
3424 /* There are more overlay strings to process. If
3425 IT->current.overlay_string_index has advanced to a position
3426 where we must load IT->overlay_strings with more strings, do
3428 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
3430 if (it
->current
.overlay_string_index
&& i
== 0)
3431 load_overlay_strings (it
, 0);
3433 /* Initialize IT to deliver display elements from the overlay
3435 it
->string
= it
->overlay_strings
[i
];
3436 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
3437 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
3438 it
->method
= next_element_from_string
;
3439 it
->stop_charpos
= 0;
3446 /* Compare two overlay_entry structures E1 and E2. Used as a
3447 comparison function for qsort in load_overlay_strings. Overlay
3448 strings for the same position are sorted so that
3450 1. All after-strings come in front of before-strings, except
3451 when they come from the same overlay.
3453 2. Within after-strings, strings are sorted so that overlay strings
3454 from overlays with higher priorities come first.
3456 2. Within before-strings, strings are sorted so that overlay
3457 strings from overlays with higher priorities come last.
3459 Value is analogous to strcmp. */
3463 compare_overlay_entries (e1
, e2
)
3466 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
3467 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
3470 if (entry1
->after_string_p
!= entry2
->after_string_p
)
3472 /* Let after-strings appear in front of before-strings if
3473 they come from different overlays. */
3474 if (EQ (entry1
->overlay
, entry2
->overlay
))
3475 result
= entry1
->after_string_p
? 1 : -1;
3477 result
= entry1
->after_string_p
? -1 : 1;
3479 else if (entry1
->after_string_p
)
3480 /* After-strings sorted in order of decreasing priority. */
3481 result
= entry2
->priority
- entry1
->priority
;
3483 /* Before-strings sorted in order of increasing priority. */
3484 result
= entry1
->priority
- entry2
->priority
;
3490 /* Load the vector IT->overlay_strings with overlay strings from IT's
3491 current buffer position, or from CHARPOS if that is > 0. Set
3492 IT->n_overlays to the total number of overlay strings found.
3494 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
3495 a time. On entry into load_overlay_strings,
3496 IT->current.overlay_string_index gives the number of overlay
3497 strings that have already been loaded by previous calls to this
3500 IT->add_overlay_start contains an additional overlay start
3501 position to consider for taking overlay strings from, if non-zero.
3502 This position comes into play when the overlay has an `invisible'
3503 property, and both before and after-strings. When we've skipped to
3504 the end of the overlay, because of its `invisible' property, we
3505 nevertheless want its before-string to appear.
3506 IT->add_overlay_start will contain the overlay start position
3509 Overlay strings are sorted so that after-string strings come in
3510 front of before-string strings. Within before and after-strings,
3511 strings are sorted by overlay priority. See also function
3512 compare_overlay_entries. */
3515 load_overlay_strings (it
, charpos
)
3519 extern Lisp_Object Qafter_string
, Qbefore_string
, Qwindow
, Qpriority
;
3520 Lisp_Object ov
, overlay
, window
, str
, invisible
;
3523 int n
= 0, i
, j
, invis_p
;
3524 struct overlay_entry
*entries
3525 = (struct overlay_entry
*) alloca (size
* sizeof *entries
);
3528 charpos
= IT_CHARPOS (*it
);
3530 /* Append the overlay string STRING of overlay OVERLAY to vector
3531 `entries' which has size `size' and currently contains `n'
3532 elements. AFTER_P non-zero means STRING is an after-string of
3534 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
3537 Lisp_Object priority; \
3541 int new_size = 2 * size; \
3542 struct overlay_entry *old = entries; \
3544 (struct overlay_entry *) alloca (new_size \
3545 * sizeof *entries); \
3546 bcopy (old, entries, size * sizeof *entries); \
3550 entries[n].string = (STRING); \
3551 entries[n].overlay = (OVERLAY); \
3552 priority = Foverlay_get ((OVERLAY), Qpriority); \
3553 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
3554 entries[n].after_string_p = (AFTER_P); \
3559 /* Process overlay before the overlay center. */
3560 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCDR (ov
))
3562 overlay
= XCAR (ov
);
3563 xassert (OVERLAYP (overlay
));
3564 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3565 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3570 /* Skip this overlay if it doesn't start or end at IT's current
3572 if (end
!= charpos
&& start
!= charpos
)
3575 /* Skip this overlay if it doesn't apply to IT->w. */
3576 window
= Foverlay_get (overlay
, Qwindow
);
3577 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
3580 /* If the text ``under'' the overlay is invisible, both before-
3581 and after-strings from this overlay are visible; start and
3582 end position are indistinguishable. */
3583 invisible
= Foverlay_get (overlay
, Qinvisible
);
3584 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
3586 /* If overlay has a non-empty before-string, record it. */
3587 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
3588 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
3590 RECORD_OVERLAY_STRING (overlay
, str
, 0);
3592 /* If overlay has a non-empty after-string, record it. */
3593 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
3594 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
3596 RECORD_OVERLAY_STRING (overlay
, str
, 1);
3599 /* Process overlays after the overlay center. */
3600 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCDR (ov
))
3602 overlay
= XCAR (ov
);
3603 xassert (OVERLAYP (overlay
));
3604 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3605 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3607 if (start
> charpos
)
3610 /* Skip this overlay if it doesn't start or end at IT's current
3612 if (end
!= charpos
&& start
!= charpos
)
3615 /* Skip this overlay if it doesn't apply to IT->w. */
3616 window
= Foverlay_get (overlay
, Qwindow
);
3617 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
3620 /* If the text ``under'' the overlay is invisible, it has a zero
3621 dimension, and both before- and after-strings apply. */
3622 invisible
= Foverlay_get (overlay
, Qinvisible
);
3623 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
3625 /* If overlay has a non-empty before-string, record it. */
3626 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
3627 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
3629 RECORD_OVERLAY_STRING (overlay
, str
, 0);
3631 /* If overlay has a non-empty after-string, record it. */
3632 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
3633 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
3635 RECORD_OVERLAY_STRING (overlay
, str
, 1);
3638 #undef RECORD_OVERLAY_STRING
3642 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
3644 /* Record the total number of strings to process. */
3645 it
->n_overlay_strings
= n
;
3647 /* IT->current.overlay_string_index is the number of overlay strings
3648 that have already been consumed by IT. Copy some of the
3649 remaining overlay strings to IT->overlay_strings. */
3651 j
= it
->current
.overlay_string_index
;
3652 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
3653 it
->overlay_strings
[i
++] = entries
[j
++].string
;
3659 /* Get the first chunk of overlay strings at IT's current buffer
3660 position, or at CHARPOS if that is > 0. Value is non-zero if at
3661 least one overlay string was found. */
3664 get_overlay_strings (it
, charpos
)
3668 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
3669 process. This fills IT->overlay_strings with strings, and sets
3670 IT->n_overlay_strings to the total number of strings to process.
3671 IT->pos.overlay_string_index has to be set temporarily to zero
3672 because load_overlay_strings needs this; it must be set to -1
3673 when no overlay strings are found because a zero value would
3674 indicate a position in the first overlay string. */
3675 it
->current
.overlay_string_index
= 0;
3676 load_overlay_strings (it
, charpos
);
3678 /* If we found overlay strings, set up IT to deliver display
3679 elements from the first one. Otherwise set up IT to deliver
3680 from current_buffer. */
3681 if (it
->n_overlay_strings
)
3683 /* Make sure we know settings in current_buffer, so that we can
3684 restore meaningful values when we're done with the overlay
3686 compute_stop_pos (it
);
3687 xassert (it
->face_id
>= 0);
3689 /* Save IT's settings. They are restored after all overlay
3690 strings have been processed. */
3691 xassert (it
->sp
== 0);
3694 /* Set up IT to deliver display elements from the first overlay
3696 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
3697 it
->string
= it
->overlay_strings
[0];
3698 it
->stop_charpos
= 0;
3699 xassert (STRINGP (it
->string
));
3700 it
->end_charpos
= SCHARS (it
->string
);
3701 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
3702 it
->method
= next_element_from_string
;
3707 it
->current
.overlay_string_index
= -1;
3708 it
->method
= next_element_from_buffer
;
3713 /* Value is non-zero if we found at least one overlay string. */
3714 return STRINGP (it
->string
);
3719 /***********************************************************************
3720 Saving and restoring state
3721 ***********************************************************************/
3723 /* Save current settings of IT on IT->stack. Called, for example,
3724 before setting up IT for an overlay string, to be able to restore
3725 IT's settings to what they were after the overlay string has been
3732 struct iterator_stack_entry
*p
;
3734 xassert (it
->sp
< 2);
3735 p
= it
->stack
+ it
->sp
;
3737 p
->stop_charpos
= it
->stop_charpos
;
3738 xassert (it
->face_id
>= 0);
3739 p
->face_id
= it
->face_id
;
3740 p
->string
= it
->string
;
3741 p
->pos
= it
->current
;
3742 p
->end_charpos
= it
->end_charpos
;
3743 p
->string_nchars
= it
->string_nchars
;
3745 p
->multibyte_p
= it
->multibyte_p
;
3746 p
->space_width
= it
->space_width
;
3747 p
->font_height
= it
->font_height
;
3748 p
->voffset
= it
->voffset
;
3749 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
3750 p
->display_ellipsis_p
= 0;
3755 /* Restore IT's settings from IT->stack. Called, for example, when no
3756 more overlay strings must be processed, and we return to delivering
3757 display elements from a buffer, or when the end of a string from a
3758 `display' property is reached and we return to delivering display
3759 elements from an overlay string, or from a buffer. */
3765 struct iterator_stack_entry
*p
;
3767 xassert (it
->sp
> 0);
3769 p
= it
->stack
+ it
->sp
;
3770 it
->stop_charpos
= p
->stop_charpos
;
3771 it
->face_id
= p
->face_id
;
3772 it
->string
= p
->string
;
3773 it
->current
= p
->pos
;
3774 it
->end_charpos
= p
->end_charpos
;
3775 it
->string_nchars
= p
->string_nchars
;
3777 it
->multibyte_p
= p
->multibyte_p
;
3778 it
->space_width
= p
->space_width
;
3779 it
->font_height
= p
->font_height
;
3780 it
->voffset
= p
->voffset
;
3781 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
3786 /***********************************************************************
3788 ***********************************************************************/
3790 /* Set IT's current position to the previous line start. */
3793 back_to_previous_line_start (it
)
3796 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
3797 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
3801 /* Move IT to the next line start.
3803 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
3804 we skipped over part of the text (as opposed to moving the iterator
3805 continuously over the text). Otherwise, don't change the value
3808 Newlines may come from buffer text, overlay strings, or strings
3809 displayed via the `display' property. That's the reason we can't
3810 simply use find_next_newline_no_quit.
3812 Note that this function may not skip over invisible text that is so
3813 because of text properties and immediately follows a newline. If
3814 it would, function reseat_at_next_visible_line_start, when called
3815 from set_iterator_to_next, would effectively make invisible
3816 characters following a newline part of the wrong glyph row, which
3817 leads to wrong cursor motion. */
3820 forward_to_next_line_start (it
, skipped_p
)
3824 int old_selective
, newline_found_p
, n
;
3825 const int MAX_NEWLINE_DISTANCE
= 500;
3827 /* If already on a newline, just consume it to avoid unintended
3828 skipping over invisible text below. */
3829 if (it
->what
== IT_CHARACTER
3831 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
3833 set_iterator_to_next (it
, 0);
3838 /* Don't handle selective display in the following. It's (a)
3839 unnecessary because it's done by the caller, and (b) leads to an
3840 infinite recursion because next_element_from_ellipsis indirectly
3841 calls this function. */
3842 old_selective
= it
->selective
;
3845 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
3846 from buffer text. */
3847 for (n
= newline_found_p
= 0;
3848 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
3849 n
+= STRINGP (it
->string
) ? 0 : 1)
3851 if (!get_next_display_element (it
))
3853 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
3854 set_iterator_to_next (it
, 0);
3857 /* If we didn't find a newline near enough, see if we can use a
3859 if (n
== MAX_NEWLINE_DISTANCE
)
3861 int start
= IT_CHARPOS (*it
);
3862 int limit
= find_next_newline_no_quit (start
, 1);
3865 xassert (!STRINGP (it
->string
));
3867 /* If there isn't any `display' property in sight, and no
3868 overlays, we can just use the position of the newline in
3870 if (it
->stop_charpos
>= limit
3871 || ((pos
= Fnext_single_property_change (make_number (start
),
3873 Qnil
, make_number (limit
)),
3875 && next_overlay_change (start
) == ZV
))
3877 IT_CHARPOS (*it
) = limit
;
3878 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
3879 *skipped_p
= newline_found_p
= 1;
3883 while (get_next_display_element (it
)
3884 && !newline_found_p
)
3886 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
3887 set_iterator_to_next (it
, 0);
3892 it
->selective
= old_selective
;
3893 return newline_found_p
;
3897 /* Set IT's current position to the previous visible line start. Skip
3898 invisible text that is so either due to text properties or due to
3899 selective display. Caution: this does not change IT->current_x and
3903 back_to_previous_visible_line_start (it
)
3908 /* Go back one newline if not on BEGV already. */
3909 if (IT_CHARPOS (*it
) > BEGV
)
3910 back_to_previous_line_start (it
);
3912 /* Move over lines that are invisible because of selective display
3913 or text properties. */
3914 while (IT_CHARPOS (*it
) > BEGV
3919 /* If selective > 0, then lines indented more than that values
3921 if (it
->selective
> 0
3922 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
3923 (double) it
->selective
)) /* iftc */
3929 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
)),
3930 Qinvisible
, it
->window
);
3931 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3935 /* Back one more newline if the current one is invisible. */
3937 back_to_previous_line_start (it
);
3940 xassert (IT_CHARPOS (*it
) >= BEGV
);
3941 xassert (IT_CHARPOS (*it
) == BEGV
3942 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
3947 /* Reseat iterator IT at the previous visible line start. Skip
3948 invisible text that is so either due to text properties or due to
3949 selective display. At the end, update IT's overlay information,
3950 face information etc. */
3953 reseat_at_previous_visible_line_start (it
)
3956 back_to_previous_visible_line_start (it
);
3957 reseat (it
, it
->current
.pos
, 1);
3962 /* Reseat iterator IT on the next visible line start in the current
3963 buffer. ON_NEWLINE_P non-zero means position IT on the newline
3964 preceding the line start. Skip over invisible text that is so
3965 because of selective display. Compute faces, overlays etc at the
3966 new position. Note that this function does not skip over text that
3967 is invisible because of text properties. */
3970 reseat_at_next_visible_line_start (it
, on_newline_p
)
3974 int newline_found_p
, skipped_p
= 0;
3976 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
3978 /* Skip over lines that are invisible because they are indented
3979 more than the value of IT->selective. */
3980 if (it
->selective
> 0)
3981 while (IT_CHARPOS (*it
) < ZV
3982 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
3983 (double) it
->selective
)) /* iftc */
3985 xassert (FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
3986 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
3989 /* Position on the newline if that's what's requested. */
3990 if (on_newline_p
&& newline_found_p
)
3992 if (STRINGP (it
->string
))
3994 if (IT_STRING_CHARPOS (*it
) > 0)
3996 --IT_STRING_CHARPOS (*it
);
3997 --IT_STRING_BYTEPOS (*it
);
4000 else if (IT_CHARPOS (*it
) > BEGV
)
4004 reseat (it
, it
->current
.pos
, 0);
4008 reseat (it
, it
->current
.pos
, 0);
4015 /***********************************************************************
4016 Changing an iterator's position
4017 ***********************************************************************/
4019 /* Change IT's current position to POS in current_buffer. If FORCE_P
4020 is non-zero, always check for text properties at the new position.
4021 Otherwise, text properties are only looked up if POS >=
4022 IT->check_charpos of a property. */
4025 reseat (it
, pos
, force_p
)
4027 struct text_pos pos
;
4030 int original_pos
= IT_CHARPOS (*it
);
4032 reseat_1 (it
, pos
, 0);
4034 /* Determine where to check text properties. Avoid doing it
4035 where possible because text property lookup is very expensive. */
4037 || CHARPOS (pos
) > it
->stop_charpos
4038 || CHARPOS (pos
) < original_pos
)
4045 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
4046 IT->stop_pos to POS, also. */
4049 reseat_1 (it
, pos
, set_stop_p
)
4051 struct text_pos pos
;
4054 /* Don't call this function when scanning a C string. */
4055 xassert (it
->s
== NULL
);
4057 /* POS must be a reasonable value. */
4058 xassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
4060 it
->current
.pos
= it
->position
= pos
;
4061 XSETBUFFER (it
->object
, current_buffer
);
4062 it
->end_charpos
= ZV
;
4064 it
->current
.dpvec_index
= -1;
4065 it
->current
.overlay_string_index
= -1;
4066 IT_STRING_CHARPOS (*it
) = -1;
4067 IT_STRING_BYTEPOS (*it
) = -1;
4069 it
->method
= next_element_from_buffer
;
4070 it
->multibyte_p
= !NILP (current_buffer
->enable_multibyte_characters
);
4072 it
->face_before_selective_p
= 0;
4075 it
->stop_charpos
= CHARPOS (pos
);
4079 /* Set up IT for displaying a string, starting at CHARPOS in window W.
4080 If S is non-null, it is a C string to iterate over. Otherwise,
4081 STRING gives a Lisp string to iterate over.
4083 If PRECISION > 0, don't return more then PRECISION number of
4084 characters from the string.
4086 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
4087 characters have been returned. FIELD_WIDTH < 0 means an infinite
4090 MULTIBYTE = 0 means disable processing of multibyte characters,
4091 MULTIBYTE > 0 means enable it,
4092 MULTIBYTE < 0 means use IT->multibyte_p.
4094 IT must be initialized via a prior call to init_iterator before
4095 calling this function. */
4098 reseat_to_string (it
, s
, string
, charpos
, precision
, field_width
, multibyte
)
4103 int precision
, field_width
, multibyte
;
4105 /* No region in strings. */
4106 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
4108 /* No text property checks performed by default, but see below. */
4109 it
->stop_charpos
= -1;
4111 /* Set iterator position and end position. */
4112 bzero (&it
->current
, sizeof it
->current
);
4113 it
->current
.overlay_string_index
= -1;
4114 it
->current
.dpvec_index
= -1;
4115 xassert (charpos
>= 0);
4117 /* If STRING is specified, use its multibyteness, otherwise use the
4118 setting of MULTIBYTE, if specified. */
4120 it
->multibyte_p
= multibyte
> 0;
4124 xassert (STRINGP (string
));
4125 it
->string
= string
;
4127 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
4128 it
->method
= next_element_from_string
;
4129 it
->current
.string_pos
= string_pos (charpos
, string
);
4136 /* Note that we use IT->current.pos, not it->current.string_pos,
4137 for displaying C strings. */
4138 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
4139 if (it
->multibyte_p
)
4141 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
4142 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
4146 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
4147 it
->end_charpos
= it
->string_nchars
= strlen (s
);
4150 it
->method
= next_element_from_c_string
;
4153 /* PRECISION > 0 means don't return more than PRECISION characters
4155 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
4156 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
4158 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
4159 characters have been returned. FIELD_WIDTH == 0 means don't pad,
4160 FIELD_WIDTH < 0 means infinite field width. This is useful for
4161 padding with `-' at the end of a mode line. */
4162 if (field_width
< 0)
4163 field_width
= INFINITY
;
4164 if (field_width
> it
->end_charpos
- charpos
)
4165 it
->end_charpos
= charpos
+ field_width
;
4167 /* Use the standard display table for displaying strings. */
4168 if (DISP_TABLE_P (Vstandard_display_table
))
4169 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
4171 it
->stop_charpos
= charpos
;
4177 /***********************************************************************
4179 ***********************************************************************/
4181 /* Load IT's display element fields with information about the next
4182 display element from the current position of IT. Value is zero if
4183 end of buffer (or C string) is reached. */
4186 get_next_display_element (it
)
4189 /* Non-zero means that we found an display element. Zero means that
4190 we hit the end of what we iterate over. Performance note: the
4191 function pointer `method' used here turns out to be faster than
4192 using a sequence of if-statements. */
4193 int success_p
= (*it
->method
) (it
);
4195 if (it
->what
== IT_CHARACTER
)
4197 /* Map via display table or translate control characters.
4198 IT->c, IT->len etc. have been set to the next character by
4199 the function call above. If we have a display table, and it
4200 contains an entry for IT->c, translate it. Don't do this if
4201 IT->c itself comes from a display table, otherwise we could
4202 end up in an infinite recursion. (An alternative could be to
4203 count the recursion depth of this function and signal an
4204 error when a certain maximum depth is reached.) Is it worth
4206 if (success_p
&& it
->dpvec
== NULL
)
4211 && (dv
= DISP_CHAR_VECTOR (it
->dp
, it
->c
),
4214 struct Lisp_Vector
*v
= XVECTOR (dv
);
4216 /* Return the first character from the display table
4217 entry, if not empty. If empty, don't display the
4218 current character. */
4221 it
->dpvec_char_len
= it
->len
;
4222 it
->dpvec
= v
->contents
;
4223 it
->dpend
= v
->contents
+ v
->size
;
4224 it
->current
.dpvec_index
= 0;
4225 it
->method
= next_element_from_display_vector
;
4226 success_p
= get_next_display_element (it
);
4230 set_iterator_to_next (it
, 0);
4231 success_p
= get_next_display_element (it
);
4235 /* Translate control characters into `\003' or `^C' form.
4236 Control characters coming from a display table entry are
4237 currently not translated because we use IT->dpvec to hold
4238 the translation. This could easily be changed but I
4239 don't believe that it is worth doing.
4241 Non-printable multibyte characters are also translated
4243 else if ((it
->c
< ' '
4244 && (it
->area
!= TEXT_AREA
4245 || (it
->c
!= '\n' && it
->c
!= '\t')))
4248 || !CHAR_PRINTABLE_P (it
->c
))
4250 /* IT->c is a control character which must be displayed
4251 either as '\003' or as `^C' where the '\\' and '^'
4252 can be defined in the display table. Fill
4253 IT->ctl_chars with glyphs for what we have to
4254 display. Then, set IT->dpvec to these glyphs. */
4257 if (it
->c
< 128 && it
->ctl_arrow_p
)
4259 /* Set IT->ctl_chars[0] to the glyph for `^'. */
4261 && INTEGERP (DISP_CTRL_GLYPH (it
->dp
))
4262 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (it
->dp
))))
4263 g
= XINT (DISP_CTRL_GLYPH (it
->dp
));
4265 g
= FAST_MAKE_GLYPH ('^', 0);
4266 XSETINT (it
->ctl_chars
[0], g
);
4268 g
= FAST_MAKE_GLYPH (it
->c
^ 0100, 0);
4269 XSETINT (it
->ctl_chars
[1], g
);
4271 /* Set up IT->dpvec and return first character from it. */
4272 it
->dpvec_char_len
= it
->len
;
4273 it
->dpvec
= it
->ctl_chars
;
4274 it
->dpend
= it
->dpvec
+ 2;
4275 it
->current
.dpvec_index
= 0;
4276 it
->method
= next_element_from_display_vector
;
4277 get_next_display_element (it
);
4281 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
4286 /* Set IT->ctl_chars[0] to the glyph for `\\'. */
4288 && INTEGERP (DISP_ESCAPE_GLYPH (it
->dp
))
4289 && GLYPH_CHAR_VALID_P (XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
))))
4290 escape_glyph
= XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
));
4292 escape_glyph
= FAST_MAKE_GLYPH ('\\', 0);
4294 if (SINGLE_BYTE_CHAR_P (it
->c
))
4295 str
[0] = it
->c
, len
= 1;
4298 len
= CHAR_STRING_NO_SIGNAL (it
->c
, str
);
4301 /* It's an invalid character, which
4302 shouldn't happen actually, but due to
4303 bugs it may happen. Let's print the char
4304 as is, there's not much meaningful we can
4307 str
[1] = it
->c
>> 8;
4308 str
[2] = it
->c
>> 16;
4309 str
[3] = it
->c
>> 24;
4314 for (i
= 0; i
< len
; i
++)
4316 XSETINT (it
->ctl_chars
[i
* 4], escape_glyph
);
4317 /* Insert three more glyphs into IT->ctl_chars for
4318 the octal display of the character. */
4319 g
= FAST_MAKE_GLYPH (((str
[i
] >> 6) & 7) + '0', 0);
4320 XSETINT (it
->ctl_chars
[i
* 4 + 1], g
);
4321 g
= FAST_MAKE_GLYPH (((str
[i
] >> 3) & 7) + '0', 0);
4322 XSETINT (it
->ctl_chars
[i
* 4 + 2], g
);
4323 g
= FAST_MAKE_GLYPH ((str
[i
] & 7) + '0', 0);
4324 XSETINT (it
->ctl_chars
[i
* 4 + 3], g
);
4327 /* Set up IT->dpvec and return the first character
4329 it
->dpvec_char_len
= it
->len
;
4330 it
->dpvec
= it
->ctl_chars
;
4331 it
->dpend
= it
->dpvec
+ len
* 4;
4332 it
->current
.dpvec_index
= 0;
4333 it
->method
= next_element_from_display_vector
;
4334 get_next_display_element (it
);
4339 /* Adjust face id for a multibyte character. There are no
4340 multibyte character in unibyte text. */
4343 && FRAME_WINDOW_P (it
->f
))
4345 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4346 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->c
);
4350 /* Is this character the last one of a run of characters with
4351 box? If yes, set IT->end_of_box_run_p to 1. */
4358 it
->end_of_box_run_p
4359 = ((face_id
= face_after_it_pos (it
),
4360 face_id
!= it
->face_id
)
4361 && (face
= FACE_FROM_ID (it
->f
, face_id
),
4362 face
->box
== FACE_NO_BOX
));
4365 /* Value is 0 if end of buffer or string reached. */
4370 /* Move IT to the next display element.
4372 RESEAT_P non-zero means if called on a newline in buffer text,
4373 skip to the next visible line start.
4375 Functions get_next_display_element and set_iterator_to_next are
4376 separate because I find this arrangement easier to handle than a
4377 get_next_display_element function that also increments IT's
4378 position. The way it is we can first look at an iterator's current
4379 display element, decide whether it fits on a line, and if it does,
4380 increment the iterator position. The other way around we probably
4381 would either need a flag indicating whether the iterator has to be
4382 incremented the next time, or we would have to implement a
4383 decrement position function which would not be easy to write. */
4386 set_iterator_to_next (it
, reseat_p
)
4390 /* Reset flags indicating start and end of a sequence of characters
4391 with box. Reset them at the start of this function because
4392 moving the iterator to a new position might set them. */
4393 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
4395 if (it
->method
== next_element_from_buffer
)
4397 /* The current display element of IT is a character from
4398 current_buffer. Advance in the buffer, and maybe skip over
4399 invisible lines that are so because of selective display. */
4400 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
4401 reseat_at_next_visible_line_start (it
, 0);
4404 xassert (it
->len
!= 0);
4405 IT_BYTEPOS (*it
) += it
->len
;
4406 IT_CHARPOS (*it
) += 1;
4407 xassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
4410 else if (it
->method
== next_element_from_composition
)
4412 xassert (it
->cmp_id
>= 0 && it
->cmp_id
< n_compositions
);
4413 if (STRINGP (it
->string
))
4415 IT_STRING_BYTEPOS (*it
) += it
->len
;
4416 IT_STRING_CHARPOS (*it
) += it
->cmp_len
;
4417 it
->method
= next_element_from_string
;
4418 goto consider_string_end
;
4422 IT_BYTEPOS (*it
) += it
->len
;
4423 IT_CHARPOS (*it
) += it
->cmp_len
;
4424 it
->method
= next_element_from_buffer
;
4427 else if (it
->method
== next_element_from_c_string
)
4429 /* Current display element of IT is from a C string. */
4430 IT_BYTEPOS (*it
) += it
->len
;
4431 IT_CHARPOS (*it
) += 1;
4433 else if (it
->method
== next_element_from_display_vector
)
4435 /* Current display element of IT is from a display table entry.
4436 Advance in the display table definition. Reset it to null if
4437 end reached, and continue with characters from buffers/
4439 ++it
->current
.dpvec_index
;
4441 /* Restore face of the iterator to what they were before the
4442 display vector entry (these entries may contain faces). */
4443 it
->face_id
= it
->saved_face_id
;
4445 if (it
->dpvec
+ it
->current
.dpvec_index
== it
->dpend
)
4448 it
->method
= next_element_from_c_string
;
4449 else if (STRINGP (it
->string
))
4450 it
->method
= next_element_from_string
;
4452 it
->method
= next_element_from_buffer
;
4455 it
->current
.dpvec_index
= -1;
4457 /* Skip over characters which were displayed via IT->dpvec. */
4458 if (it
->dpvec_char_len
< 0)
4459 reseat_at_next_visible_line_start (it
, 1);
4460 else if (it
->dpvec_char_len
> 0)
4462 it
->len
= it
->dpvec_char_len
;
4463 set_iterator_to_next (it
, reseat_p
);
4467 else if (it
->method
== next_element_from_string
)
4469 /* Current display element is a character from a Lisp string. */
4470 xassert (it
->s
== NULL
&& STRINGP (it
->string
));
4471 IT_STRING_BYTEPOS (*it
) += it
->len
;
4472 IT_STRING_CHARPOS (*it
) += 1;
4474 consider_string_end
:
4476 if (it
->current
.overlay_string_index
>= 0)
4478 /* IT->string is an overlay string. Advance to the
4479 next, if there is one. */
4480 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
4481 next_overlay_string (it
);
4485 /* IT->string is not an overlay string. If we reached
4486 its end, and there is something on IT->stack, proceed
4487 with what is on the stack. This can be either another
4488 string, this time an overlay string, or a buffer. */
4489 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
4493 if (!STRINGP (it
->string
))
4494 it
->method
= next_element_from_buffer
;
4496 goto consider_string_end
;
4500 else if (it
->method
== next_element_from_image
4501 || it
->method
== next_element_from_stretch
)
4503 /* The position etc with which we have to proceed are on
4504 the stack. The position may be at the end of a string,
4505 if the `display' property takes up the whole string. */
4508 if (STRINGP (it
->string
))
4510 it
->method
= next_element_from_string
;
4511 goto consider_string_end
;
4514 it
->method
= next_element_from_buffer
;
4517 /* There are no other methods defined, so this should be a bug. */
4520 xassert (it
->method
!= next_element_from_string
4521 || (STRINGP (it
->string
)
4522 && IT_STRING_CHARPOS (*it
) >= 0));
4526 /* Load IT's display element fields with information about the next
4527 display element which comes from a display table entry or from the
4528 result of translating a control character to one of the forms `^C'
4529 or `\003'. IT->dpvec holds the glyphs to return as characters. */
4532 next_element_from_display_vector (it
)
4536 xassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
4538 /* Remember the current face id in case glyphs specify faces.
4539 IT's face is restored in set_iterator_to_next. */
4540 it
->saved_face_id
= it
->face_id
;
4542 if (INTEGERP (*it
->dpvec
)
4543 && GLYPH_CHAR_VALID_P (XFASTINT (*it
->dpvec
)))
4548 g
= XFASTINT (it
->dpvec
[it
->current
.dpvec_index
]);
4549 it
->c
= FAST_GLYPH_CHAR (g
);
4550 it
->len
= CHAR_BYTES (it
->c
);
4552 /* The entry may contain a face id to use. Such a face id is
4553 the id of a Lisp face, not a realized face. A face id of
4554 zero means no face is specified. */
4555 lface_id
= FAST_GLYPH_FACE (g
);
4558 /* The function returns -1 if lface_id is invalid. */
4559 int face_id
= ascii_face_of_lisp_face (it
->f
, lface_id
);
4561 it
->face_id
= face_id
;
4565 /* Display table entry is invalid. Return a space. */
4566 it
->c
= ' ', it
->len
= 1;
4568 /* Don't change position and object of the iterator here. They are
4569 still the values of the character that had this display table
4570 entry or was translated, and that's what we want. */
4571 it
->what
= IT_CHARACTER
;
4576 /* Load IT with the next display element from Lisp string IT->string.
4577 IT->current.string_pos is the current position within the string.
4578 If IT->current.overlay_string_index >= 0, the Lisp string is an
4582 next_element_from_string (it
)
4585 struct text_pos position
;
4587 xassert (STRINGP (it
->string
));
4588 xassert (IT_STRING_CHARPOS (*it
) >= 0);
4589 position
= it
->current
.string_pos
;
4591 /* Time to check for invisible text? */
4592 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
4593 && IT_STRING_CHARPOS (*it
) == it
->stop_charpos
)
4597 /* Since a handler may have changed IT->method, we must
4599 return get_next_display_element (it
);
4602 if (it
->current
.overlay_string_index
>= 0)
4604 /* Get the next character from an overlay string. In overlay
4605 strings, There is no field width or padding with spaces to
4607 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
4612 else if (STRING_MULTIBYTE (it
->string
))
4614 int remaining
= SBYTES (it
->string
) - IT_STRING_BYTEPOS (*it
);
4615 const unsigned char *s
= (SDATA (it
->string
)
4616 + IT_STRING_BYTEPOS (*it
));
4617 it
->c
= string_char_and_length (s
, remaining
, &it
->len
);
4621 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
4627 /* Get the next character from a Lisp string that is not an
4628 overlay string. Such strings come from the mode line, for
4629 example. We may have to pad with spaces, or truncate the
4630 string. See also next_element_from_c_string. */
4631 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
4636 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
4638 /* Pad with spaces. */
4639 it
->c
= ' ', it
->len
= 1;
4640 CHARPOS (position
) = BYTEPOS (position
) = -1;
4642 else if (STRING_MULTIBYTE (it
->string
))
4644 int maxlen
= SBYTES (it
->string
) - IT_STRING_BYTEPOS (*it
);
4645 const unsigned char *s
= (SDATA (it
->string
)
4646 + IT_STRING_BYTEPOS (*it
));
4647 it
->c
= string_char_and_length (s
, maxlen
, &it
->len
);
4651 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
4656 /* Record what we have and where it came from. Note that we store a
4657 buffer position in IT->position although it could arguably be a
4659 it
->what
= IT_CHARACTER
;
4660 it
->object
= it
->string
;
4661 it
->position
= position
;
4666 /* Load IT with next display element from C string IT->s.
4667 IT->string_nchars is the maximum number of characters to return
4668 from the string. IT->end_charpos may be greater than
4669 IT->string_nchars when this function is called, in which case we
4670 may have to return padding spaces. Value is zero if end of string
4671 reached, including padding spaces. */
4674 next_element_from_c_string (it
)
4680 it
->what
= IT_CHARACTER
;
4681 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
4684 /* IT's position can be greater IT->string_nchars in case a field
4685 width or precision has been specified when the iterator was
4687 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
4689 /* End of the game. */
4693 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
4695 /* Pad with spaces. */
4696 it
->c
= ' ', it
->len
= 1;
4697 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
4699 else if (it
->multibyte_p
)
4701 /* Implementation note: The calls to strlen apparently aren't a
4702 performance problem because there is no noticeable performance
4703 difference between Emacs running in unibyte or multibyte mode. */
4704 int maxlen
= strlen (it
->s
) - IT_BYTEPOS (*it
);
4705 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
),
4709 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
4715 /* Set up IT to return characters from an ellipsis, if appropriate.
4716 The definition of the ellipsis glyphs may come from a display table
4717 entry. This function Fills IT with the first glyph from the
4718 ellipsis if an ellipsis is to be displayed. */
4721 next_element_from_ellipsis (it
)
4724 if (it
->selective_display_ellipsis_p
)
4726 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4728 /* Use the display table definition for `...'. Invalid glyphs
4729 will be handled by the method returning elements from dpvec. */
4730 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4731 it
->dpvec_char_len
= it
->len
;
4732 it
->dpvec
= v
->contents
;
4733 it
->dpend
= v
->contents
+ v
->size
;
4734 it
->current
.dpvec_index
= 0;
4735 it
->method
= next_element_from_display_vector
;
4739 /* Use default `...' which is stored in default_invis_vector. */
4740 it
->dpvec_char_len
= it
->len
;
4741 it
->dpvec
= default_invis_vector
;
4742 it
->dpend
= default_invis_vector
+ 3;
4743 it
->current
.dpvec_index
= 0;
4744 it
->method
= next_element_from_display_vector
;
4749 /* The face at the current position may be different from the
4750 face we find after the invisible text. Remember what it
4751 was in IT->saved_face_id, and signal that it's there by
4752 setting face_before_selective_p. */
4753 it
->saved_face_id
= it
->face_id
;
4754 it
->method
= next_element_from_buffer
;
4755 reseat_at_next_visible_line_start (it
, 1);
4756 it
->face_before_selective_p
= 1;
4759 return get_next_display_element (it
);
4763 /* Deliver an image display element. The iterator IT is already
4764 filled with image information (done in handle_display_prop). Value
4769 next_element_from_image (it
)
4772 it
->what
= IT_IMAGE
;
4777 /* Fill iterator IT with next display element from a stretch glyph
4778 property. IT->object is the value of the text property. Value is
4782 next_element_from_stretch (it
)
4785 it
->what
= IT_STRETCH
;
4790 /* Load IT with the next display element from current_buffer. Value
4791 is zero if end of buffer reached. IT->stop_charpos is the next
4792 position at which to stop and check for text properties or buffer
4796 next_element_from_buffer (it
)
4801 /* Check this assumption, otherwise, we would never enter the
4802 if-statement, below. */
4803 xassert (IT_CHARPOS (*it
) >= BEGV
4804 && IT_CHARPOS (*it
) <= it
->stop_charpos
);
4806 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
4808 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
4810 int overlay_strings_follow_p
;
4812 /* End of the game, except when overlay strings follow that
4813 haven't been returned yet. */
4814 if (it
->overlay_strings_at_end_processed_p
)
4815 overlay_strings_follow_p
= 0;
4818 it
->overlay_strings_at_end_processed_p
= 1;
4819 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
4822 if (overlay_strings_follow_p
)
4823 success_p
= get_next_display_element (it
);
4827 it
->position
= it
->current
.pos
;
4834 return get_next_display_element (it
);
4839 /* No face changes, overlays etc. in sight, so just return a
4840 character from current_buffer. */
4843 /* Maybe run the redisplay end trigger hook. Performance note:
4844 This doesn't seem to cost measurable time. */
4845 if (it
->redisplay_end_trigger_charpos
4847 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
4848 run_redisplay_end_trigger_hook (it
);
4850 /* Get the next character, maybe multibyte. */
4851 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
4852 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
4854 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT_BYTE
? ZV_BYTE
: GPT_BYTE
)
4855 - IT_BYTEPOS (*it
));
4856 it
->c
= string_char_and_length (p
, maxlen
, &it
->len
);
4859 it
->c
= *p
, it
->len
= 1;
4861 /* Record what we have and where it came from. */
4862 it
->what
= IT_CHARACTER
;;
4863 it
->object
= it
->w
->buffer
;
4864 it
->position
= it
->current
.pos
;
4866 /* Normally we return the character found above, except when we
4867 really want to return an ellipsis for selective display. */
4872 /* A value of selective > 0 means hide lines indented more
4873 than that number of columns. */
4874 if (it
->selective
> 0
4875 && IT_CHARPOS (*it
) + 1 < ZV
4876 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
4877 IT_BYTEPOS (*it
) + 1,
4878 (double) it
->selective
)) /* iftc */
4880 success_p
= next_element_from_ellipsis (it
);
4881 it
->dpvec_char_len
= -1;
4884 else if (it
->c
== '\r' && it
->selective
== -1)
4886 /* A value of selective == -1 means that everything from the
4887 CR to the end of the line is invisible, with maybe an
4888 ellipsis displayed for it. */
4889 success_p
= next_element_from_ellipsis (it
);
4890 it
->dpvec_char_len
= -1;
4895 /* Value is zero if end of buffer reached. */
4896 xassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
4901 /* Run the redisplay end trigger hook for IT. */
4904 run_redisplay_end_trigger_hook (it
)
4907 Lisp_Object args
[3];
4909 /* IT->glyph_row should be non-null, i.e. we should be actually
4910 displaying something, or otherwise we should not run the hook. */
4911 xassert (it
->glyph_row
);
4913 /* Set up hook arguments. */
4914 args
[0] = Qredisplay_end_trigger_functions
;
4915 args
[1] = it
->window
;
4916 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
4917 it
->redisplay_end_trigger_charpos
= 0;
4919 /* Since we are *trying* to run these functions, don't try to run
4920 them again, even if they get an error. */
4921 it
->w
->redisplay_end_trigger
= Qnil
;
4922 Frun_hook_with_args (3, args
);
4924 /* Notice if it changed the face of the character we are on. */
4925 handle_face_prop (it
);
4929 /* Deliver a composition display element. The iterator IT is already
4930 filled with composition information (done in
4931 handle_composition_prop). Value is always 1. */
4934 next_element_from_composition (it
)
4937 it
->what
= IT_COMPOSITION
;
4938 it
->position
= (STRINGP (it
->string
)
4939 ? it
->current
.string_pos
4946 /***********************************************************************
4947 Moving an iterator without producing glyphs
4948 ***********************************************************************/
4950 /* Move iterator IT to a specified buffer or X position within one
4951 line on the display without producing glyphs.
4953 OP should be a bit mask including some or all of these bits:
4954 MOVE_TO_X: Stop on reaching x-position TO_X.
4955 MOVE_TO_POS: Stop on reaching buffer or string position TO_CHARPOS.
4956 Regardless of OP's value, stop in reaching the end of the display line.
4958 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
4959 This means, in particular, that TO_X includes window's horizontal
4962 The return value has several possible values that
4963 say what condition caused the scan to stop:
4965 MOVE_POS_MATCH_OR_ZV
4966 - when TO_POS or ZV was reached.
4969 -when TO_X was reached before TO_POS or ZV were reached.
4972 - when we reached the end of the display area and the line must
4976 - when we reached the end of the display area and the line is
4980 - when we stopped at a line end, i.e. a newline or a CR and selective
4983 static enum move_it_result
4984 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
)
4986 int to_charpos
, to_x
, op
;
4988 enum move_it_result result
= MOVE_UNDEFINED
;
4989 struct glyph_row
*saved_glyph_row
;
4991 /* Don't produce glyphs in produce_glyphs. */
4992 saved_glyph_row
= it
->glyph_row
;
4993 it
->glyph_row
= NULL
;
4997 int x
, i
, ascent
= 0, descent
= 0;
4999 /* Stop when ZV or TO_CHARPOS reached. */
5000 if (!get_next_display_element (it
)
5001 || ((op
& MOVE_TO_POS
) != 0
5002 && BUFFERP (it
->object
)
5003 && IT_CHARPOS (*it
) >= to_charpos
))
5005 result
= MOVE_POS_MATCH_OR_ZV
;
5009 /* The call to produce_glyphs will get the metrics of the
5010 display element IT is loaded with. We record in x the
5011 x-position before this display element in case it does not
5015 /* Remember the line height so far in case the next element doesn't
5017 if (!it
->truncate_lines_p
)
5019 ascent
= it
->max_ascent
;
5020 descent
= it
->max_descent
;
5023 PRODUCE_GLYPHS (it
);
5025 if (it
->area
!= TEXT_AREA
)
5027 set_iterator_to_next (it
, 1);
5031 /* The number of glyphs we get back in IT->nglyphs will normally
5032 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
5033 character on a terminal frame, or (iii) a line end. For the
5034 second case, IT->nglyphs - 1 padding glyphs will be present
5035 (on X frames, there is only one glyph produced for a
5036 composite character.
5038 The behavior implemented below means, for continuation lines,
5039 that as many spaces of a TAB as fit on the current line are
5040 displayed there. For terminal frames, as many glyphs of a
5041 multi-glyph character are displayed in the current line, too.
5042 This is what the old redisplay code did, and we keep it that
5043 way. Under X, the whole shape of a complex character must
5044 fit on the line or it will be completely displayed in the
5047 Note that both for tabs and padding glyphs, all glyphs have
5051 /* More than one glyph or glyph doesn't fit on line. All
5052 glyphs have the same width. */
5053 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
5056 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
5058 new_x
= x
+ single_glyph_width
;
5060 /* We want to leave anything reaching TO_X to the caller. */
5061 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
5064 result
= MOVE_X_REACHED
;
5067 else if (/* Lines are continued. */
5068 !it
->truncate_lines_p
5069 && (/* And glyph doesn't fit on the line. */
5070 new_x
> it
->last_visible_x
5071 /* Or it fits exactly and we're on a window
5073 || (new_x
== it
->last_visible_x
5074 && FRAME_WINDOW_P (it
->f
))))
5076 if (/* IT->hpos == 0 means the very first glyph
5077 doesn't fit on the line, e.g. a wide image. */
5079 || (new_x
== it
->last_visible_x
5080 && FRAME_WINDOW_P (it
->f
)))
5083 it
->current_x
= new_x
;
5084 if (i
== it
->nglyphs
- 1)
5085 set_iterator_to_next (it
, 1);
5090 it
->max_ascent
= ascent
;
5091 it
->max_descent
= descent
;
5094 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
5096 result
= MOVE_LINE_CONTINUED
;
5099 else if (new_x
> it
->first_visible_x
)
5101 /* Glyph is visible. Increment number of glyphs that
5102 would be displayed. */
5107 /* Glyph is completely off the left margin of the display
5108 area. Nothing to do. */
5112 if (result
!= MOVE_UNDEFINED
)
5115 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
5117 /* Stop when TO_X specified and reached. This check is
5118 necessary here because of lines consisting of a line end,
5119 only. The line end will not produce any glyphs and we
5120 would never get MOVE_X_REACHED. */
5121 xassert (it
->nglyphs
== 0);
5122 result
= MOVE_X_REACHED
;
5126 /* Is this a line end? If yes, we're done. */
5127 if (ITERATOR_AT_END_OF_LINE_P (it
))
5129 result
= MOVE_NEWLINE_OR_CR
;
5133 /* The current display element has been consumed. Advance
5135 set_iterator_to_next (it
, 1);
5137 /* Stop if lines are truncated and IT's current x-position is
5138 past the right edge of the window now. */
5139 if (it
->truncate_lines_p
5140 && it
->current_x
>= it
->last_visible_x
)
5142 result
= MOVE_LINE_TRUNCATED
;
5147 /* Restore the iterator settings altered at the beginning of this
5149 it
->glyph_row
= saved_glyph_row
;
5154 /* Move IT forward until it satisfies one or more of the criteria in
5155 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
5157 OP is a bit-mask that specifies where to stop, and in particular,
5158 which of those four position arguments makes a difference. See the
5159 description of enum move_operation_enum.
5161 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
5162 screen line, this function will set IT to the next position >
5166 move_it_to (it
, to_charpos
, to_x
, to_y
, to_vpos
, op
)
5168 int to_charpos
, to_x
, to_y
, to_vpos
;
5171 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
5177 if (op
& MOVE_TO_VPOS
)
5179 /* If no TO_CHARPOS and no TO_X specified, stop at the
5180 start of the line TO_VPOS. */
5181 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
5183 if (it
->vpos
== to_vpos
)
5189 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
5193 /* TO_VPOS >= 0 means stop at TO_X in the line at
5194 TO_VPOS, or at TO_POS, whichever comes first. */
5195 if (it
->vpos
== to_vpos
)
5201 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
5203 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
5208 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
5210 /* We have reached TO_X but not in the line we want. */
5211 skip
= move_it_in_display_line_to (it
, to_charpos
,
5213 if (skip
== MOVE_POS_MATCH_OR_ZV
)
5221 else if (op
& MOVE_TO_Y
)
5223 struct it it_backup
;
5225 /* TO_Y specified means stop at TO_X in the line containing
5226 TO_Y---or at TO_CHARPOS if this is reached first. The
5227 problem is that we can't really tell whether the line
5228 contains TO_Y before we have completely scanned it, and
5229 this may skip past TO_X. What we do is to first scan to
5232 If TO_X is not specified, use a TO_X of zero. The reason
5233 is to make the outcome of this function more predictable.
5234 If we didn't use TO_X == 0, we would stop at the end of
5235 the line which is probably not what a caller would expect
5237 skip
= move_it_in_display_line_to (it
, to_charpos
,
5241 | (op
& MOVE_TO_POS
)));
5243 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
5244 if (skip
== MOVE_POS_MATCH_OR_ZV
)
5250 /* If TO_X was reached, we would like to know whether TO_Y
5251 is in the line. This can only be said if we know the
5252 total line height which requires us to scan the rest of
5254 if (skip
== MOVE_X_REACHED
)
5257 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
5258 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
5260 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
5263 /* Now, decide whether TO_Y is in this line. */
5264 line_height
= it
->max_ascent
+ it
->max_descent
;
5265 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
5267 if (to_y
>= it
->current_y
5268 && to_y
< it
->current_y
+ line_height
)
5270 if (skip
== MOVE_X_REACHED
)
5271 /* If TO_Y is in this line and TO_X was reached above,
5272 we scanned too far. We have to restore IT's settings
5273 to the ones before skipping. */
5277 else if (skip
== MOVE_X_REACHED
)
5280 if (skip
== MOVE_POS_MATCH_OR_ZV
)
5288 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
5292 case MOVE_POS_MATCH_OR_ZV
:
5296 case MOVE_NEWLINE_OR_CR
:
5297 set_iterator_to_next (it
, 1);
5298 it
->continuation_lines_width
= 0;
5301 case MOVE_LINE_TRUNCATED
:
5302 it
->continuation_lines_width
= 0;
5303 reseat_at_next_visible_line_start (it
, 0);
5304 if ((op
& MOVE_TO_POS
) != 0
5305 && IT_CHARPOS (*it
) > to_charpos
)
5312 case MOVE_LINE_CONTINUED
:
5313 it
->continuation_lines_width
+= it
->current_x
;
5320 /* Reset/increment for the next run. */
5321 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
5322 it
->current_x
= it
->hpos
= 0;
5323 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
5325 last_height
= it
->max_ascent
+ it
->max_descent
;
5326 last_max_ascent
= it
->max_ascent
;
5327 it
->max_ascent
= it
->max_descent
= 0;
5332 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
5336 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
5338 If DY > 0, move IT backward at least that many pixels. DY = 0
5339 means move IT backward to the preceding line start or BEGV. This
5340 function may move over more than DY pixels if IT->current_y - DY
5341 ends up in the middle of a line; in this case IT->current_y will be
5342 set to the top of the line moved to. */
5345 move_it_vertically_backward (it
, dy
)
5351 int start_pos
= IT_CHARPOS (*it
);
5355 /* Estimate how many newlines we must move back. */
5356 nlines
= max (1, dy
/ CANON_Y_UNIT (it
->f
));
5358 /* Set the iterator's position that many lines back. */
5359 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
5360 back_to_previous_visible_line_start (it
);
5362 /* Reseat the iterator here. When moving backward, we don't want
5363 reseat to skip forward over invisible text, set up the iterator
5364 to deliver from overlay strings at the new position etc. So,
5365 use reseat_1 here. */
5366 reseat_1 (it
, it
->current
.pos
, 1);
5368 /* We are now surely at a line start. */
5369 it
->current_x
= it
->hpos
= 0;
5371 /* Move forward and see what y-distance we moved. First move to the
5372 start of the next line so that we get its height. We need this
5373 height to be able to tell whether we reached the specified
5376 it2
.max_ascent
= it2
.max_descent
= 0;
5377 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
5378 MOVE_TO_POS
| MOVE_TO_VPOS
);
5379 xassert (IT_CHARPOS (*it
) >= BEGV
);
5382 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
5383 xassert (IT_CHARPOS (*it
) >= BEGV
);
5384 h
= it2
.current_y
- it
->current_y
;
5385 nlines
= it2
.vpos
- it
->vpos
;
5387 /* Correct IT's y and vpos position. */
5393 /* DY == 0 means move to the start of the screen line. The
5394 value of nlines is > 0 if continuation lines were involved. */
5396 move_it_by_lines (it
, nlines
, 1);
5397 xassert (IT_CHARPOS (*it
) <= start_pos
);
5401 /* The y-position we try to reach. Note that h has been
5402 subtracted in front of the if-statement. */
5403 int target_y
= it
->current_y
+ h
- dy
;
5404 int y0
= it3
.current_y
;
5405 int y1
= line_bottom_y (&it3
);
5406 int line_height
= y1
- y0
;
5408 /* If we did not reach target_y, try to move further backward if
5409 we can. If we moved too far backward, try to move forward. */
5410 if (target_y
< it
->current_y
5411 /* This is heuristic. In a window that's 3 lines high, with
5412 a line height of 13 pixels each, recentering with point
5413 on the bottom line will try to move -39/2 = 19 pixels
5414 backward. Try to avoid moving into the first line. */
5415 && it
->current_y
- target_y
> line_height
/ 3 * 2
5416 && IT_CHARPOS (*it
) > BEGV
)
5418 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
5419 target_y
- it
->current_y
));
5420 move_it_vertically (it
, target_y
- it
->current_y
);
5421 xassert (IT_CHARPOS (*it
) >= BEGV
);
5423 else if (target_y
>= it
->current_y
+ line_height
5424 && IT_CHARPOS (*it
) < ZV
)
5426 /* Should move forward by at least one line, maybe more.
5428 Note: Calling move_it_by_lines can be expensive on
5429 terminal frames, where compute_motion is used (via
5430 vmotion) to do the job, when there are very long lines
5431 and truncate-lines is nil. That's the reason for
5432 treating terminal frames specially here. */
5434 if (!FRAME_WINDOW_P (it
->f
))
5435 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
5440 move_it_by_lines (it
, 1, 1);
5442 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
5445 xassert (IT_CHARPOS (*it
) >= BEGV
);
5451 /* Move IT by a specified amount of pixel lines DY. DY negative means
5452 move backwards. DY = 0 means move to start of screen line. At the
5453 end, IT will be on the start of a screen line. */
5456 move_it_vertically (it
, dy
)
5461 move_it_vertically_backward (it
, -dy
);
5464 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
5465 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
5466 MOVE_TO_POS
| MOVE_TO_Y
);
5467 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
5469 /* If buffer ends in ZV without a newline, move to the start of
5470 the line to satisfy the post-condition. */
5471 if (IT_CHARPOS (*it
) == ZV
5472 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
5473 move_it_by_lines (it
, 0, 0);
5478 /* Move iterator IT past the end of the text line it is in. */
5481 move_it_past_eol (it
)
5484 enum move_it_result rc
;
5486 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
5487 if (rc
== MOVE_NEWLINE_OR_CR
)
5488 set_iterator_to_next (it
, 0);
5492 #if 0 /* Currently not used. */
5494 /* Return non-zero if some text between buffer positions START_CHARPOS
5495 and END_CHARPOS is invisible. IT->window is the window for text
5499 invisible_text_between_p (it
, start_charpos
, end_charpos
)
5501 int start_charpos
, end_charpos
;
5503 Lisp_Object prop
, limit
;
5504 int invisible_found_p
;
5506 xassert (it
!= NULL
&& start_charpos
<= end_charpos
);
5508 /* Is text at START invisible? */
5509 prop
= Fget_char_property (make_number (start_charpos
), Qinvisible
,
5511 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
5512 invisible_found_p
= 1;
5515 limit
= Fnext_single_char_property_change (make_number (start_charpos
),
5517 make_number (end_charpos
));
5518 invisible_found_p
= XFASTINT (limit
) < end_charpos
;
5521 return invisible_found_p
;
5527 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
5528 negative means move up. DVPOS == 0 means move to the start of the
5529 screen line. NEED_Y_P non-zero means calculate IT->current_y. If
5530 NEED_Y_P is zero, IT->current_y will be left unchanged.
5532 Further optimization ideas: If we would know that IT->f doesn't use
5533 a face with proportional font, we could be faster for
5534 truncate-lines nil. */
5537 move_it_by_lines (it
, dvpos
, need_y_p
)
5539 int dvpos
, need_y_p
;
5541 struct position pos
;
5543 if (!FRAME_WINDOW_P (it
->f
))
5545 struct text_pos textpos
;
5547 /* We can use vmotion on frames without proportional fonts. */
5548 pos
= *vmotion (IT_CHARPOS (*it
), dvpos
, it
->w
);
5549 SET_TEXT_POS (textpos
, pos
.bufpos
, pos
.bytepos
);
5550 reseat (it
, textpos
, 1);
5551 it
->vpos
+= pos
.vpos
;
5552 it
->current_y
+= pos
.vpos
;
5554 else if (dvpos
== 0)
5556 /* DVPOS == 0 means move to the start of the screen line. */
5557 move_it_vertically_backward (it
, 0);
5558 xassert (it
->current_x
== 0 && it
->hpos
== 0);
5561 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
5565 int start_charpos
, i
;
5567 /* Start at the beginning of the screen line containing IT's
5569 move_it_vertically_backward (it
, 0);
5571 /* Go back -DVPOS visible lines and reseat the iterator there. */
5572 start_charpos
= IT_CHARPOS (*it
);
5573 for (i
= -dvpos
; i
&& IT_CHARPOS (*it
) > BEGV
; --i
)
5574 back_to_previous_visible_line_start (it
);
5575 reseat (it
, it
->current
.pos
, 1);
5576 it
->current_x
= it
->hpos
= 0;
5578 /* Above call may have moved too far if continuation lines
5579 are involved. Scan forward and see if it did. */
5581 it2
.vpos
= it2
.current_y
= 0;
5582 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
5583 it
->vpos
-= it2
.vpos
;
5584 it
->current_y
-= it2
.current_y
;
5585 it
->current_x
= it
->hpos
= 0;
5587 /* If we moved too far, move IT some lines forward. */
5588 if (it2
.vpos
> -dvpos
)
5590 int delta
= it2
.vpos
+ dvpos
;
5591 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
5598 /***********************************************************************
5600 ***********************************************************************/
5603 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
5607 add_to_log (format
, arg1
, arg2
)
5609 Lisp_Object arg1
, arg2
;
5611 Lisp_Object args
[3];
5612 Lisp_Object msg
, fmt
;
5615 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5617 /* Do nothing if called asynchronously. Inserting text into
5618 a buffer may call after-change-functions and alike and
5619 that would means running Lisp asynchronously. */
5620 if (handling_signal
)
5624 GCPRO4 (fmt
, msg
, arg1
, arg2
);
5626 args
[0] = fmt
= build_string (format
);
5629 msg
= Fformat (3, args
);
5631 len
= SBYTES (msg
) + 1;
5632 buffer
= (char *) alloca (len
);
5633 bcopy (SDATA (msg
), buffer
, len
);
5635 message_dolog (buffer
, len
- 1, 1, 0);
5640 /* Output a newline in the *Messages* buffer if "needs" one. */
5643 message_log_maybe_newline ()
5645 if (message_log_need_newline
)
5646 message_dolog ("", 0, 1, 0);
5650 /* Add a string M of length NBYTES to the message log, optionally
5651 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
5652 nonzero, means interpret the contents of M as multibyte. This
5653 function calls low-level routines in order to bypass text property
5654 hooks, etc. which might not be safe to run. */
5657 message_dolog (m
, nbytes
, nlflag
, multibyte
)
5659 int nbytes
, nlflag
, multibyte
;
5661 if (!NILP (Vmemory_full
))
5664 if (!NILP (Vmessage_log_max
))
5666 struct buffer
*oldbuf
;
5667 Lisp_Object oldpoint
, oldbegv
, oldzv
;
5668 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5669 int point_at_end
= 0;
5671 Lisp_Object old_deactivate_mark
, tem
;
5672 struct gcpro gcpro1
;
5674 old_deactivate_mark
= Vdeactivate_mark
;
5675 oldbuf
= current_buffer
;
5676 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
5677 current_buffer
->undo_list
= Qt
;
5679 oldpoint
= message_dolog_marker1
;
5680 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
5681 oldbegv
= message_dolog_marker2
;
5682 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
5683 oldzv
= message_dolog_marker3
;
5684 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
5685 GCPRO1 (old_deactivate_mark
);
5693 BEGV_BYTE
= BEG_BYTE
;
5696 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
5698 /* Insert the string--maybe converting multibyte to single byte
5699 or vice versa, so that all the text fits the buffer. */
5701 && NILP (current_buffer
->enable_multibyte_characters
))
5703 int i
, c
, char_bytes
;
5704 unsigned char work
[1];
5706 /* Convert a multibyte string to single-byte
5707 for the *Message* buffer. */
5708 for (i
= 0; i
< nbytes
; i
+= nbytes
)
5710 c
= string_char_and_length (m
+ i
, nbytes
- i
, &char_bytes
);
5711 work
[0] = (SINGLE_BYTE_CHAR_P (c
)
5713 : multibyte_char_to_unibyte (c
, Qnil
));
5714 insert_1_both (work
, 1, 1, 1, 0, 0);
5717 else if (! multibyte
5718 && ! NILP (current_buffer
->enable_multibyte_characters
))
5720 int i
, c
, char_bytes
;
5721 unsigned char *msg
= (unsigned char *) m
;
5722 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
5723 /* Convert a single-byte string to multibyte
5724 for the *Message* buffer. */
5725 for (i
= 0; i
< nbytes
; i
++)
5727 c
= unibyte_char_to_multibyte (msg
[i
]);
5728 char_bytes
= CHAR_STRING (c
, str
);
5729 insert_1_both (str
, 1, char_bytes
, 1, 0, 0);
5733 insert_1 (m
, nbytes
, 1, 0, 0);
5737 int this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
, dup
;
5738 insert_1 ("\n", 1, 1, 0, 0);
5740 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
5742 this_bol_byte
= PT_BYTE
;
5744 /* See if this line duplicates the previous one.
5745 If so, combine duplicates. */
5748 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
5750 prev_bol_byte
= PT_BYTE
;
5752 dup
= message_log_check_duplicate (prev_bol
, prev_bol_byte
,
5753 this_bol
, this_bol_byte
);
5756 del_range_both (prev_bol
, prev_bol_byte
,
5757 this_bol
, this_bol_byte
, 0);
5763 /* If you change this format, don't forget to also
5764 change message_log_check_duplicate. */
5765 sprintf (dupstr
, " [%d times]", dup
);
5766 duplen
= strlen (dupstr
);
5767 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
5768 insert_1 (dupstr
, duplen
, 1, 0, 1);
5773 /* If we have more than the desired maximum number of lines
5774 in the *Messages* buffer now, delete the oldest ones.
5775 This is safe because we don't have undo in this buffer. */
5777 if (NATNUMP (Vmessage_log_max
))
5779 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
5780 -XFASTINT (Vmessage_log_max
) - 1, 0);
5781 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
5784 BEGV
= XMARKER (oldbegv
)->charpos
;
5785 BEGV_BYTE
= marker_byte_position (oldbegv
);
5794 ZV
= XMARKER (oldzv
)->charpos
;
5795 ZV_BYTE
= marker_byte_position (oldzv
);
5799 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
5801 /* We can't do Fgoto_char (oldpoint) because it will run some
5803 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
5804 XMARKER (oldpoint
)->bytepos
);
5807 unchain_marker (oldpoint
);
5808 unchain_marker (oldbegv
);
5809 unchain_marker (oldzv
);
5811 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
5812 set_buffer_internal (oldbuf
);
5814 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5815 message_log_need_newline
= !nlflag
;
5816 Vdeactivate_mark
= old_deactivate_mark
;
5821 /* We are at the end of the buffer after just having inserted a newline.
5822 (Note: We depend on the fact we won't be crossing the gap.)
5823 Check to see if the most recent message looks a lot like the previous one.
5824 Return 0 if different, 1 if the new one should just replace it, or a
5825 value N > 1 if we should also append " [N times]". */
5828 message_log_check_duplicate (prev_bol
, prev_bol_byte
, this_bol
, this_bol_byte
)
5829 int prev_bol
, this_bol
;
5830 int prev_bol_byte
, this_bol_byte
;
5833 int len
= Z_BYTE
- 1 - this_bol_byte
;
5835 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
5836 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
5838 for (i
= 0; i
< len
; i
++)
5840 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
5848 if (*p1
++ == ' ' && *p1
++ == '[')
5851 while (*p1
>= '0' && *p1
<= '9')
5852 n
= n
* 10 + *p1
++ - '0';
5853 if (strncmp (p1
, " times]\n", 8) == 0)
5860 /* Display an echo area message M with a specified length of NBYTES
5861 bytes. The string may include null characters. If M is 0, clear
5862 out any existing message, and let the mini-buffer text show
5865 The buffer M must continue to exist until after the echo area gets
5866 cleared or some other message gets displayed there. This means do
5867 not pass text that is stored in a Lisp string; do not pass text in
5868 a buffer that was alloca'd. */
5871 message2 (m
, nbytes
, multibyte
)
5876 /* First flush out any partial line written with print. */
5877 message_log_maybe_newline ();
5879 message_dolog (m
, nbytes
, 1, multibyte
);
5880 message2_nolog (m
, nbytes
, multibyte
);
5884 /* The non-logging counterpart of message2. */
5887 message2_nolog (m
, nbytes
, multibyte
)
5891 struct frame
*sf
= SELECTED_FRAME ();
5892 message_enable_multibyte
= multibyte
;
5896 if (noninteractive_need_newline
)
5897 putc ('\n', stderr
);
5898 noninteractive_need_newline
= 0;
5900 fwrite (m
, nbytes
, 1, stderr
);
5901 if (cursor_in_echo_area
== 0)
5902 fprintf (stderr
, "\n");
5905 /* A null message buffer means that the frame hasn't really been
5906 initialized yet. Error messages get reported properly by
5907 cmd_error, so this must be just an informative message; toss it. */
5908 else if (INTERACTIVE
5909 && sf
->glyphs_initialized_p
5910 && FRAME_MESSAGE_BUF (sf
))
5912 Lisp_Object mini_window
;
5915 /* Get the frame containing the mini-buffer
5916 that the selected frame is using. */
5917 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
5918 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
5920 FRAME_SAMPLE_VISIBILITY (f
);
5921 if (FRAME_VISIBLE_P (sf
)
5922 && ! FRAME_VISIBLE_P (f
))
5923 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
5927 set_message (m
, Qnil
, nbytes
, multibyte
);
5928 if (minibuffer_auto_raise
)
5929 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
5932 clear_message (1, 1);
5934 do_pending_window_change (0);
5935 echo_area_display (1);
5936 do_pending_window_change (0);
5937 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
5938 (*frame_up_to_date_hook
) (f
);
5943 /* Display an echo area message M with a specified length of NBYTES
5944 bytes. The string may include null characters. If M is not a
5945 string, clear out any existing message, and let the mini-buffer
5946 text show through. */
5949 message3 (m
, nbytes
, multibyte
)
5954 struct gcpro gcpro1
;
5958 /* First flush out any partial line written with print. */
5959 message_log_maybe_newline ();
5961 message_dolog (SDATA (m
), nbytes
, 1, multibyte
);
5962 message3_nolog (m
, nbytes
, multibyte
);
5968 /* The non-logging version of message3. */
5971 message3_nolog (m
, nbytes
, multibyte
)
5973 int nbytes
, multibyte
;
5975 struct frame
*sf
= SELECTED_FRAME ();
5976 message_enable_multibyte
= multibyte
;
5980 if (noninteractive_need_newline
)
5981 putc ('\n', stderr
);
5982 noninteractive_need_newline
= 0;
5984 fwrite (SDATA (m
), nbytes
, 1, stderr
);
5985 if (cursor_in_echo_area
== 0)
5986 fprintf (stderr
, "\n");
5989 /* A null message buffer means that the frame hasn't really been
5990 initialized yet. Error messages get reported properly by
5991 cmd_error, so this must be just an informative message; toss it. */
5992 else if (INTERACTIVE
5993 && sf
->glyphs_initialized_p
5994 && FRAME_MESSAGE_BUF (sf
))
5996 Lisp_Object mini_window
;
6000 /* Get the frame containing the mini-buffer
6001 that the selected frame is using. */
6002 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6003 frame
= XWINDOW (mini_window
)->frame
;
6006 FRAME_SAMPLE_VISIBILITY (f
);
6007 if (FRAME_VISIBLE_P (sf
)
6008 && !FRAME_VISIBLE_P (f
))
6009 Fmake_frame_visible (frame
);
6011 if (STRINGP (m
) && SCHARS (m
) > 0)
6013 set_message (NULL
, m
, nbytes
, multibyte
);
6014 if (minibuffer_auto_raise
)
6015 Fraise_frame (frame
);
6018 clear_message (1, 1);
6020 do_pending_window_change (0);
6021 echo_area_display (1);
6022 do_pending_window_change (0);
6023 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
6024 (*frame_up_to_date_hook
) (f
);
6029 /* Display a null-terminated echo area message M. If M is 0, clear
6030 out any existing message, and let the mini-buffer text show through.
6032 The buffer M must continue to exist until after the echo area gets
6033 cleared or some other message gets displayed there. Do not pass
6034 text that is stored in a Lisp string. Do not pass text in a buffer
6035 that was alloca'd. */
6041 message2 (m
, (m
? strlen (m
) : 0), 0);
6045 /* The non-logging counterpart of message1. */
6051 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
6054 /* Display a message M which contains a single %s
6055 which gets replaced with STRING. */
6058 message_with_string (m
, string
, log
)
6063 CHECK_STRING (string
);
6069 if (noninteractive_need_newline
)
6070 putc ('\n', stderr
);
6071 noninteractive_need_newline
= 0;
6072 fprintf (stderr
, m
, SDATA (string
));
6073 if (cursor_in_echo_area
== 0)
6074 fprintf (stderr
, "\n");
6078 else if (INTERACTIVE
)
6080 /* The frame whose minibuffer we're going to display the message on.
6081 It may be larger than the selected frame, so we need
6082 to use its buffer, not the selected frame's buffer. */
6083 Lisp_Object mini_window
;
6084 struct frame
*f
, *sf
= SELECTED_FRAME ();
6086 /* Get the frame containing the minibuffer
6087 that the selected frame is using. */
6088 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6089 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
6091 /* A null message buffer means that the frame hasn't really been
6092 initialized yet. Error messages get reported properly by
6093 cmd_error, so this must be just an informative message; toss it. */
6094 if (FRAME_MESSAGE_BUF (f
))
6096 Lisp_Object args
[2], message
;
6097 struct gcpro gcpro1
, gcpro2
;
6099 args
[0] = build_string (m
);
6100 args
[1] = message
= string
;
6101 GCPRO2 (args
[0], message
);
6104 message
= Fformat (2, args
);
6107 message3 (message
, SBYTES (message
), STRING_MULTIBYTE (message
));
6109 message3_nolog (message
, SBYTES (message
), STRING_MULTIBYTE (message
));
6113 /* Print should start at the beginning of the message
6114 buffer next time. */
6115 message_buf_print
= 0;
6121 /* Dump an informative message to the minibuf. If M is 0, clear out
6122 any existing message, and let the mini-buffer text show through. */
6126 message (m
, a1
, a2
, a3
)
6128 EMACS_INT a1
, a2
, a3
;
6134 if (noninteractive_need_newline
)
6135 putc ('\n', stderr
);
6136 noninteractive_need_newline
= 0;
6137 fprintf (stderr
, m
, a1
, a2
, a3
);
6138 if (cursor_in_echo_area
== 0)
6139 fprintf (stderr
, "\n");
6143 else if (INTERACTIVE
)
6145 /* The frame whose mini-buffer we're going to display the message
6146 on. It may be larger than the selected frame, so we need to
6147 use its buffer, not the selected frame's buffer. */
6148 Lisp_Object mini_window
;
6149 struct frame
*f
, *sf
= SELECTED_FRAME ();
6151 /* Get the frame containing the mini-buffer
6152 that the selected frame is using. */
6153 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6154 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
6156 /* A null message buffer means that the frame hasn't really been
6157 initialized yet. Error messages get reported properly by
6158 cmd_error, so this must be just an informative message; toss
6160 if (FRAME_MESSAGE_BUF (f
))
6171 len
= doprnt (FRAME_MESSAGE_BUF (f
),
6172 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
6174 len
= doprnt (FRAME_MESSAGE_BUF (f
),
6175 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3,
6177 #endif /* NO_ARG_ARRAY */
6179 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
6184 /* Print should start at the beginning of the message
6185 buffer next time. */
6186 message_buf_print
= 0;
6192 /* The non-logging version of message. */
6195 message_nolog (m
, a1
, a2
, a3
)
6197 EMACS_INT a1
, a2
, a3
;
6199 Lisp_Object old_log_max
;
6200 old_log_max
= Vmessage_log_max
;
6201 Vmessage_log_max
= Qnil
;
6202 message (m
, a1
, a2
, a3
);
6203 Vmessage_log_max
= old_log_max
;
6207 /* Display the current message in the current mini-buffer. This is
6208 only called from error handlers in process.c, and is not time
6214 if (!NILP (echo_area_buffer
[0]))
6217 string
= Fcurrent_message ();
6218 message3 (string
, SBYTES (string
),
6219 !NILP (current_buffer
->enable_multibyte_characters
));
6224 /* Make sure echo area buffers in `echo_buffers' are live.
6225 If they aren't, make new ones. */
6228 ensure_echo_area_buffers ()
6232 for (i
= 0; i
< 2; ++i
)
6233 if (!BUFFERP (echo_buffer
[i
])
6234 || NILP (XBUFFER (echo_buffer
[i
])->name
))
6237 Lisp_Object old_buffer
;
6240 old_buffer
= echo_buffer
[i
];
6241 sprintf (name
, " *Echo Area %d*", i
);
6242 echo_buffer
[i
] = Fget_buffer_create (build_string (name
));
6243 XBUFFER (echo_buffer
[i
])->truncate_lines
= Qnil
;
6245 for (j
= 0; j
< 2; ++j
)
6246 if (EQ (old_buffer
, echo_area_buffer
[j
]))
6247 echo_area_buffer
[j
] = echo_buffer
[i
];
6252 /* Call FN with args A1..A4 with either the current or last displayed
6253 echo_area_buffer as current buffer.
6255 WHICH zero means use the current message buffer
6256 echo_area_buffer[0]. If that is nil, choose a suitable buffer
6257 from echo_buffer[] and clear it.
6259 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
6260 suitable buffer from echo_buffer[] and clear it.
6262 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
6263 that the current message becomes the last displayed one, make
6264 choose a suitable buffer for echo_area_buffer[0], and clear it.
6266 Value is what FN returns. */
6269 with_echo_area_buffer (w
, which
, fn
, a1
, a2
, a3
, a4
)
6272 int (*fn
) P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
6278 int this_one
, the_other
, clear_buffer_p
, rc
;
6279 int count
= SPECPDL_INDEX ();
6281 /* If buffers aren't live, make new ones. */
6282 ensure_echo_area_buffers ();
6287 this_one
= 0, the_other
= 1;
6289 this_one
= 1, the_other
= 0;
6292 this_one
= 0, the_other
= 1;
6295 /* We need a fresh one in case the current echo buffer equals
6296 the one containing the last displayed echo area message. */
6297 if (!NILP (echo_area_buffer
[this_one
])
6298 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
6299 echo_area_buffer
[this_one
] = Qnil
;
6302 /* Choose a suitable buffer from echo_buffer[] is we don't
6304 if (NILP (echo_area_buffer
[this_one
]))
6306 echo_area_buffer
[this_one
]
6307 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
6308 ? echo_buffer
[the_other
]
6309 : echo_buffer
[this_one
]);
6313 buffer
= echo_area_buffer
[this_one
];
6315 /* Don't get confused by reusing the buffer used for echoing
6316 for a different purpose. */
6317 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
6320 record_unwind_protect (unwind_with_echo_area_buffer
,
6321 with_echo_area_buffer_unwind_data (w
));
6323 /* Make the echo area buffer current. Note that for display
6324 purposes, it is not necessary that the displayed window's buffer
6325 == current_buffer, except for text property lookup. So, let's
6326 only set that buffer temporarily here without doing a full
6327 Fset_window_buffer. We must also change w->pointm, though,
6328 because otherwise an assertions in unshow_buffer fails, and Emacs
6330 set_buffer_internal_1 (XBUFFER (buffer
));
6334 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
6337 current_buffer
->undo_list
= Qt
;
6338 current_buffer
->read_only
= Qnil
;
6339 specbind (Qinhibit_read_only
, Qt
);
6340 specbind (Qinhibit_modification_hooks
, Qt
);
6342 if (clear_buffer_p
&& Z
> BEG
)
6345 xassert (BEGV
>= BEG
);
6346 xassert (ZV
<= Z
&& ZV
>= BEGV
);
6348 rc
= fn (a1
, a2
, a3
, a4
);
6350 xassert (BEGV
>= BEG
);
6351 xassert (ZV
<= Z
&& ZV
>= BEGV
);
6353 unbind_to (count
, Qnil
);
6358 /* Save state that should be preserved around the call to the function
6359 FN called in with_echo_area_buffer. */
6362 with_echo_area_buffer_unwind_data (w
)
6368 /* Reduce consing by keeping one vector in
6369 Vwith_echo_area_save_vector. */
6370 vector
= Vwith_echo_area_save_vector
;
6371 Vwith_echo_area_save_vector
= Qnil
;
6374 vector
= Fmake_vector (make_number (7), Qnil
);
6376 XSETBUFFER (AREF (vector
, i
), current_buffer
); ++i
;
6377 AREF (vector
, i
) = Vdeactivate_mark
, ++i
;
6378 AREF (vector
, i
) = make_number (windows_or_buffers_changed
), ++i
;
6382 XSETWINDOW (AREF (vector
, i
), w
); ++i
;
6383 AREF (vector
, i
) = w
->buffer
; ++i
;
6384 AREF (vector
, i
) = make_number (XMARKER (w
->pointm
)->charpos
); ++i
;
6385 AREF (vector
, i
) = make_number (XMARKER (w
->pointm
)->bytepos
); ++i
;
6390 for (; i
< end
; ++i
)
6391 AREF (vector
, i
) = Qnil
;
6394 xassert (i
== ASIZE (vector
));
6399 /* Restore global state from VECTOR which was created by
6400 with_echo_area_buffer_unwind_data. */
6403 unwind_with_echo_area_buffer (vector
)
6406 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
6407 Vdeactivate_mark
= AREF (vector
, 1);
6408 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
6410 if (WINDOWP (AREF (vector
, 3)))
6413 Lisp_Object buffer
, charpos
, bytepos
;
6415 w
= XWINDOW (AREF (vector
, 3));
6416 buffer
= AREF (vector
, 4);
6417 charpos
= AREF (vector
, 5);
6418 bytepos
= AREF (vector
, 6);
6421 set_marker_both (w
->pointm
, buffer
,
6422 XFASTINT (charpos
), XFASTINT (bytepos
));
6425 Vwith_echo_area_save_vector
= vector
;
6430 /* Set up the echo area for use by print functions. MULTIBYTE_P
6431 non-zero means we will print multibyte. */
6434 setup_echo_area_for_printing (multibyte_p
)
6437 ensure_echo_area_buffers ();
6439 if (!message_buf_print
)
6441 /* A message has been output since the last time we printed.
6442 Choose a fresh echo area buffer. */
6443 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
6444 echo_area_buffer
[0] = echo_buffer
[1];
6446 echo_area_buffer
[0] = echo_buffer
[0];
6448 /* Switch to that buffer and clear it. */
6449 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
6450 current_buffer
->truncate_lines
= Qnil
;
6454 int count
= SPECPDL_INDEX ();
6455 specbind (Qinhibit_read_only
, Qt
);
6456 /* Note that undo recording is always disabled. */
6458 unbind_to (count
, Qnil
);
6460 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
6462 /* Set up the buffer for the multibyteness we need. */
6464 != !NILP (current_buffer
->enable_multibyte_characters
))
6465 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
6467 /* Raise the frame containing the echo area. */
6468 if (minibuffer_auto_raise
)
6470 struct frame
*sf
= SELECTED_FRAME ();
6471 Lisp_Object mini_window
;
6472 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6473 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
6476 message_log_maybe_newline ();
6477 message_buf_print
= 1;
6481 if (NILP (echo_area_buffer
[0]))
6483 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
6484 echo_area_buffer
[0] = echo_buffer
[1];
6486 echo_area_buffer
[0] = echo_buffer
[0];
6489 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
6491 /* Someone switched buffers between print requests. */
6492 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
6493 current_buffer
->truncate_lines
= Qnil
;
6499 /* Display an echo area message in window W. Value is non-zero if W's
6500 height is changed. If display_last_displayed_message_p is
6501 non-zero, display the message that was last displayed, otherwise
6502 display the current message. */
6505 display_echo_area (w
)
6508 int i
, no_message_p
, window_height_changed_p
, count
;
6510 /* Temporarily disable garbage collections while displaying the echo
6511 area. This is done because a GC can print a message itself.
6512 That message would modify the echo area buffer's contents while a
6513 redisplay of the buffer is going on, and seriously confuse
6515 count
= inhibit_garbage_collection ();
6517 /* If there is no message, we must call display_echo_area_1
6518 nevertheless because it resizes the window. But we will have to
6519 reset the echo_area_buffer in question to nil at the end because
6520 with_echo_area_buffer will sets it to an empty buffer. */
6521 i
= display_last_displayed_message_p
? 1 : 0;
6522 no_message_p
= NILP (echo_area_buffer
[i
]);
6524 window_height_changed_p
6525 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
6526 display_echo_area_1
,
6527 (EMACS_INT
) w
, Qnil
, 0, 0);
6530 echo_area_buffer
[i
] = Qnil
;
6532 unbind_to (count
, Qnil
);
6533 return window_height_changed_p
;
6537 /* Helper for display_echo_area. Display the current buffer which
6538 contains the current echo area message in window W, a mini-window,
6539 a pointer to which is passed in A1. A2..A4 are currently not used.
6540 Change the height of W so that all of the message is displayed.
6541 Value is non-zero if height of W was changed. */
6544 display_echo_area_1 (a1
, a2
, a3
, a4
)
6549 struct window
*w
= (struct window
*) a1
;
6551 struct text_pos start
;
6552 int window_height_changed_p
= 0;
6554 /* Do this before displaying, so that we have a large enough glyph
6555 matrix for the display. */
6556 window_height_changed_p
= resize_mini_window (w
, 0);
6559 clear_glyph_matrix (w
->desired_matrix
);
6560 XSETWINDOW (window
, w
);
6561 SET_TEXT_POS (start
, BEG
, BEG_BYTE
);
6562 try_window (window
, start
);
6564 return window_height_changed_p
;
6568 /* Resize the echo area window to exactly the size needed for the
6569 currently displayed message, if there is one. If a mini-buffer
6570 is active, don't shrink it. */
6573 resize_echo_area_exactly ()
6575 if (BUFFERP (echo_area_buffer
[0])
6576 && WINDOWP (echo_area_window
))
6578 struct window
*w
= XWINDOW (echo_area_window
);
6580 Lisp_Object resize_exactly
;
6582 if (minibuf_level
== 0)
6583 resize_exactly
= Qt
;
6585 resize_exactly
= Qnil
;
6587 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
6588 (EMACS_INT
) w
, resize_exactly
, 0, 0);
6591 ++windows_or_buffers_changed
;
6592 ++update_mode_lines
;
6593 redisplay_internal (0);
6599 /* Callback function for with_echo_area_buffer, when used from
6600 resize_echo_area_exactly. A1 contains a pointer to the window to
6601 resize, EXACTLY non-nil means resize the mini-window exactly to the
6602 size of the text displayed. A3 and A4 are not used. Value is what
6603 resize_mini_window returns. */
6606 resize_mini_window_1 (a1
, exactly
, a3
, a4
)
6608 Lisp_Object exactly
;
6611 return resize_mini_window ((struct window
*) a1
, !NILP (exactly
));
6615 /* Resize mini-window W to fit the size of its contents. EXACT:P
6616 means size the window exactly to the size needed. Otherwise, it's
6617 only enlarged until W's buffer is empty. Value is non-zero if
6618 the window height has been changed. */
6621 resize_mini_window (w
, exact_p
)
6625 struct frame
*f
= XFRAME (w
->frame
);
6626 int window_height_changed_p
= 0;
6628 xassert (MINI_WINDOW_P (w
));
6630 /* Don't resize windows while redisplaying a window; it would
6631 confuse redisplay functions when the size of the window they are
6632 displaying changes from under them. Such a resizing can happen,
6633 for instance, when which-func prints a long message while
6634 we are running fontification-functions. We're running these
6635 functions with safe_call which binds inhibit-redisplay to t. */
6636 if (!NILP (Vinhibit_redisplay
))
6639 /* Nil means don't try to resize. */
6640 if (NILP (Vresize_mini_windows
)
6641 || (FRAME_X_P (f
) && f
->output_data
.x
== NULL
))
6644 if (!FRAME_MINIBUF_ONLY_P (f
))
6647 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6648 int total_height
= XFASTINT (root
->height
) + XFASTINT (w
->height
);
6649 int height
, max_height
;
6650 int unit
= CANON_Y_UNIT (f
);
6651 struct text_pos start
;
6652 struct buffer
*old_current_buffer
= NULL
;
6654 if (current_buffer
!= XBUFFER (w
->buffer
))
6656 old_current_buffer
= current_buffer
;
6657 set_buffer_internal (XBUFFER (w
->buffer
));
6660 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
6662 /* Compute the max. number of lines specified by the user. */
6663 if (FLOATP (Vmax_mini_window_height
))
6664 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_HEIGHT (f
);
6665 else if (INTEGERP (Vmax_mini_window_height
))
6666 max_height
= XINT (Vmax_mini_window_height
);
6668 max_height
= total_height
/ 4;
6670 /* Correct that max. height if it's bogus. */
6671 max_height
= max (1, max_height
);
6672 max_height
= min (total_height
, max_height
);
6674 /* Find out the height of the text in the window. */
6675 if (it
.truncate_lines_p
)
6680 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
6681 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
6682 height
= it
.current_y
+ last_height
;
6684 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
6685 height
-= it
.extra_line_spacing
;
6686 height
= (height
+ unit
- 1) / unit
;
6689 /* Compute a suitable window start. */
6690 if (height
> max_height
)
6692 height
= max_height
;
6693 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
6694 move_it_vertically_backward (&it
, (height
- 1) * unit
);
6695 start
= it
.current
.pos
;
6698 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
6699 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
6701 if (EQ (Vresize_mini_windows
, Qgrow_only
))
6703 /* Let it grow only, until we display an empty message, in which
6704 case the window shrinks again. */
6705 if (height
> XFASTINT (w
->height
))
6707 int old_height
= XFASTINT (w
->height
);
6708 freeze_window_starts (f
, 1);
6709 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6710 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6712 else if (height
< XFASTINT (w
->height
)
6713 && (exact_p
|| BEGV
== ZV
))
6715 int old_height
= XFASTINT (w
->height
);
6716 freeze_window_starts (f
, 0);
6717 shrink_mini_window (w
);
6718 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6723 /* Always resize to exact size needed. */
6724 if (height
> XFASTINT (w
->height
))
6726 int old_height
= XFASTINT (w
->height
);
6727 freeze_window_starts (f
, 1);
6728 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6729 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6731 else if (height
< XFASTINT (w
->height
))
6733 int old_height
= XFASTINT (w
->height
);
6734 freeze_window_starts (f
, 0);
6735 shrink_mini_window (w
);
6739 freeze_window_starts (f
, 1);
6740 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6743 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6747 if (old_current_buffer
)
6748 set_buffer_internal (old_current_buffer
);
6751 return window_height_changed_p
;
6755 /* Value is the current message, a string, or nil if there is no
6763 if (NILP (echo_area_buffer
[0]))
6767 with_echo_area_buffer (0, 0, current_message_1
,
6768 (EMACS_INT
) &msg
, Qnil
, 0, 0);
6770 echo_area_buffer
[0] = Qnil
;
6778 current_message_1 (a1
, a2
, a3
, a4
)
6783 Lisp_Object
*msg
= (Lisp_Object
*) a1
;
6786 *msg
= make_buffer_string (BEG
, Z
, 1);
6793 /* Push the current message on Vmessage_stack for later restauration
6794 by restore_message. Value is non-zero if the current message isn't
6795 empty. This is a relatively infrequent operation, so it's not
6796 worth optimizing. */
6802 msg
= current_message ();
6803 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
6804 return STRINGP (msg
);
6808 /* Handler for record_unwind_protect calling pop_message. */
6811 push_message_unwind (dummy
)
6819 /* Restore message display from the top of Vmessage_stack. */
6826 xassert (CONSP (Vmessage_stack
));
6827 msg
= XCAR (Vmessage_stack
);
6829 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
6831 message3_nolog (msg
, 0, 0);
6835 /* Pop the top-most entry off Vmessage_stack. */
6840 xassert (CONSP (Vmessage_stack
));
6841 Vmessage_stack
= XCDR (Vmessage_stack
);
6845 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
6846 exits. If the stack is not empty, we have a missing pop_message
6850 check_message_stack ()
6852 if (!NILP (Vmessage_stack
))
6857 /* Truncate to NCHARS what will be displayed in the echo area the next
6858 time we display it---but don't redisplay it now. */
6861 truncate_echo_area (nchars
)
6865 echo_area_buffer
[0] = Qnil
;
6866 /* A null message buffer means that the frame hasn't really been
6867 initialized yet. Error messages get reported properly by
6868 cmd_error, so this must be just an informative message; toss it. */
6869 else if (!noninteractive
6871 && !NILP (echo_area_buffer
[0]))
6873 struct frame
*sf
= SELECTED_FRAME ();
6874 if (FRAME_MESSAGE_BUF (sf
))
6875 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
6880 /* Helper function for truncate_echo_area. Truncate the current
6881 message to at most NCHARS characters. */
6884 truncate_message_1 (nchars
, a2
, a3
, a4
)
6889 if (BEG
+ nchars
< Z
)
6890 del_range (BEG
+ nchars
, Z
);
6892 echo_area_buffer
[0] = Qnil
;
6897 /* Set the current message to a substring of S or STRING.
6899 If STRING is a Lisp string, set the message to the first NBYTES
6900 bytes from STRING. NBYTES zero means use the whole string. If
6901 STRING is multibyte, the message will be displayed multibyte.
6903 If S is not null, set the message to the first LEN bytes of S. LEN
6904 zero means use the whole string. MULTIBYTE_P non-zero means S is
6905 multibyte. Display the message multibyte in that case. */
6908 set_message (s
, string
, nbytes
, multibyte_p
)
6913 message_enable_multibyte
6914 = ((s
&& multibyte_p
)
6915 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
6917 with_echo_area_buffer (0, -1, set_message_1
,
6918 (EMACS_INT
) s
, string
, nbytes
, multibyte_p
);
6919 message_buf_print
= 0;
6920 help_echo_showing_p
= 0;
6924 /* Helper function for set_message. Arguments have the same meaning
6925 as there, with A1 corresponding to S and A2 corresponding to STRING
6926 This function is called with the echo area buffer being
6930 set_message_1 (a1
, a2
, nbytes
, multibyte_p
)
6933 EMACS_INT nbytes
, multibyte_p
;
6935 const char *s
= (const char *) a1
;
6936 Lisp_Object string
= a2
;
6940 /* Change multibyteness of the echo buffer appropriately. */
6941 if (message_enable_multibyte
6942 != !NILP (current_buffer
->enable_multibyte_characters
))
6943 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
6945 current_buffer
->truncate_lines
= message_truncate_lines
? Qt
: Qnil
;
6947 /* Insert new message at BEG. */
6948 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
6950 if (STRINGP (string
))
6955 nbytes
= SBYTES (string
);
6956 nchars
= string_byte_to_char (string
, nbytes
);
6958 /* This function takes care of single/multibyte conversion. We
6959 just have to ensure that the echo area buffer has the right
6960 setting of enable_multibyte_characters. */
6961 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
6966 nbytes
= strlen (s
);
6968 if (multibyte_p
&& NILP (current_buffer
->enable_multibyte_characters
))
6970 /* Convert from multi-byte to single-byte. */
6972 unsigned char work
[1];
6974 /* Convert a multibyte string to single-byte. */
6975 for (i
= 0; i
< nbytes
; i
+= n
)
6977 c
= string_char_and_length (s
+ i
, nbytes
- i
, &n
);
6978 work
[0] = (SINGLE_BYTE_CHAR_P (c
)
6980 : multibyte_char_to_unibyte (c
, Qnil
));
6981 insert_1_both (work
, 1, 1, 1, 0, 0);
6984 else if (!multibyte_p
6985 && !NILP (current_buffer
->enable_multibyte_characters
))
6987 /* Convert from single-byte to multi-byte. */
6989 const unsigned char *msg
= (const unsigned char *) s
;
6990 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
6992 /* Convert a single-byte string to multibyte. */
6993 for (i
= 0; i
< nbytes
; i
++)
6995 c
= unibyte_char_to_multibyte (msg
[i
]);
6996 n
= CHAR_STRING (c
, str
);
6997 insert_1_both (str
, 1, n
, 1, 0, 0);
7001 insert_1 (s
, nbytes
, 1, 0, 0);
7008 /* Clear messages. CURRENT_P non-zero means clear the current
7009 message. LAST_DISPLAYED_P non-zero means clear the message
7013 clear_message (current_p
, last_displayed_p
)
7014 int current_p
, last_displayed_p
;
7018 echo_area_buffer
[0] = Qnil
;
7019 message_cleared_p
= 1;
7022 if (last_displayed_p
)
7023 echo_area_buffer
[1] = Qnil
;
7025 message_buf_print
= 0;
7028 /* Clear garbaged frames.
7030 This function is used where the old redisplay called
7031 redraw_garbaged_frames which in turn called redraw_frame which in
7032 turn called clear_frame. The call to clear_frame was a source of
7033 flickering. I believe a clear_frame is not necessary. It should
7034 suffice in the new redisplay to invalidate all current matrices,
7035 and ensure a complete redisplay of all windows. */
7038 clear_garbaged_frames ()
7042 Lisp_Object tail
, frame
;
7043 int changed_count
= 0;
7045 FOR_EACH_FRAME (tail
, frame
)
7047 struct frame
*f
= XFRAME (frame
);
7049 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
7052 Fredraw_frame (frame
);
7053 clear_current_matrices (f
);
7062 ++windows_or_buffers_changed
;
7067 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
7068 is non-zero update selected_frame. Value is non-zero if the
7069 mini-windows height has been changed. */
7072 echo_area_display (update_frame_p
)
7075 Lisp_Object mini_window
;
7078 int window_height_changed_p
= 0;
7079 struct frame
*sf
= SELECTED_FRAME ();
7081 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
7082 w
= XWINDOW (mini_window
);
7083 f
= XFRAME (WINDOW_FRAME (w
));
7085 /* Don't display if frame is invisible or not yet initialized. */
7086 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
7089 /* The terminal frame is used as the first Emacs frame on the Mac OS. */
7091 #ifdef HAVE_WINDOW_SYSTEM
7092 /* When Emacs starts, selected_frame may be a visible terminal
7093 frame, even if we run under a window system. If we let this
7094 through, a message would be displayed on the terminal. */
7095 if (EQ (selected_frame
, Vterminal_frame
)
7096 && !NILP (Vwindow_system
))
7098 #endif /* HAVE_WINDOW_SYSTEM */
7101 /* Redraw garbaged frames. */
7103 clear_garbaged_frames ();
7105 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
7107 echo_area_window
= mini_window
;
7108 window_height_changed_p
= display_echo_area (w
);
7109 w
->must_be_updated_p
= 1;
7111 /* Update the display, unless called from redisplay_internal.
7112 Also don't update the screen during redisplay itself. The
7113 update will happen at the end of redisplay, and an update
7114 here could cause confusion. */
7115 if (update_frame_p
&& !redisplaying_p
)
7119 /* If the display update has been interrupted by pending
7120 input, update mode lines in the frame. Due to the
7121 pending input, it might have been that redisplay hasn't
7122 been called, so that mode lines above the echo area are
7123 garbaged. This looks odd, so we prevent it here. */
7124 if (!display_completed
)
7125 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
7127 if (window_height_changed_p
7128 /* Don't do this if Emacs is shutting down. Redisplay
7129 needs to run hooks. */
7130 && !NILP (Vrun_hooks
))
7132 /* Must update other windows. Likewise as in other
7133 cases, don't let this update be interrupted by
7135 int count
= SPECPDL_INDEX ();
7136 specbind (Qredisplay_dont_pause
, Qt
);
7137 windows_or_buffers_changed
= 1;
7138 redisplay_internal (0);
7139 unbind_to (count
, Qnil
);
7141 else if (FRAME_WINDOW_P (f
) && n
== 0)
7143 /* Window configuration is the same as before.
7144 Can do with a display update of the echo area,
7145 unless we displayed some mode lines. */
7146 update_single_window (w
, 1);
7147 rif
->flush_display (f
);
7150 update_frame (f
, 1, 1);
7152 /* If cursor is in the echo area, make sure that the next
7153 redisplay displays the minibuffer, so that the cursor will
7154 be replaced with what the minibuffer wants. */
7155 if (cursor_in_echo_area
)
7156 ++windows_or_buffers_changed
;
7159 else if (!EQ (mini_window
, selected_window
))
7160 windows_or_buffers_changed
++;
7162 /* Last displayed message is now the current message. */
7163 echo_area_buffer
[1] = echo_area_buffer
[0];
7165 /* Prevent redisplay optimization in redisplay_internal by resetting
7166 this_line_start_pos. This is done because the mini-buffer now
7167 displays the message instead of its buffer text. */
7168 if (EQ (mini_window
, selected_window
))
7169 CHARPOS (this_line_start_pos
) = 0;
7171 return window_height_changed_p
;
7176 /***********************************************************************
7178 ***********************************************************************/
7181 /* The frame title buffering code is also used by Fformat_mode_line.
7182 So it is not conditioned by HAVE_WINDOW_SYSTEM. */
7184 /* A buffer for constructing frame titles in it; allocated from the
7185 heap in init_xdisp and resized as needed in store_frame_title_char. */
7187 static char *frame_title_buf
;
7189 /* The buffer's end, and a current output position in it. */
7191 static char *frame_title_buf_end
;
7192 static char *frame_title_ptr
;
7195 /* Store a single character C for the frame title in frame_title_buf.
7196 Re-allocate frame_title_buf if necessary. */
7199 store_frame_title_char (c
)
7202 /* If output position has reached the end of the allocated buffer,
7203 double the buffer's size. */
7204 if (frame_title_ptr
== frame_title_buf_end
)
7206 int len
= frame_title_ptr
- frame_title_buf
;
7207 int new_size
= 2 * len
* sizeof *frame_title_buf
;
7208 frame_title_buf
= (char *) xrealloc (frame_title_buf
, new_size
);
7209 frame_title_buf_end
= frame_title_buf
+ new_size
;
7210 frame_title_ptr
= frame_title_buf
+ len
;
7213 *frame_title_ptr
++ = c
;
7217 /* Store part of a frame title in frame_title_buf, beginning at
7218 frame_title_ptr. STR is the string to store. Do not copy
7219 characters that yield more columns than PRECISION; PRECISION <= 0
7220 means copy the whole string. Pad with spaces until FIELD_WIDTH
7221 number of characters have been copied; FIELD_WIDTH <= 0 means don't
7222 pad. Called from display_mode_element when it is used to build a
7226 store_frame_title (str
, field_width
, precision
)
7227 const unsigned char *str
;
7228 int field_width
, precision
;
7233 /* Copy at most PRECISION chars from STR. */
7234 nbytes
= strlen (str
);
7235 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
7237 store_frame_title_char (*str
++);
7239 /* Fill up with spaces until FIELD_WIDTH reached. */
7240 while (field_width
> 0
7243 store_frame_title_char (' ');
7250 #ifdef HAVE_WINDOW_SYSTEM
7252 /* Set the title of FRAME, if it has changed. The title format is
7253 Vicon_title_format if FRAME is iconified, otherwise it is
7254 frame_title_format. */
7257 x_consider_frame_title (frame
)
7260 struct frame
*f
= XFRAME (frame
);
7262 if (FRAME_WINDOW_P (f
)
7263 || FRAME_MINIBUF_ONLY_P (f
)
7264 || f
->explicit_name
)
7266 /* Do we have more than one visible frame on this X display? */
7269 struct buffer
*obuf
;
7273 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
7275 Lisp_Object other_frame
= XCAR (tail
);
7276 struct frame
*tf
= XFRAME (other_frame
);
7279 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
7280 && !FRAME_MINIBUF_ONLY_P (tf
)
7281 && !EQ (other_frame
, tip_frame
)
7282 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
7286 /* Set global variable indicating that multiple frames exist. */
7287 multiple_frames
= CONSP (tail
);
7289 /* Switch to the buffer of selected window of the frame. Set up
7290 frame_title_ptr so that display_mode_element will output into it;
7291 then display the title. */
7292 obuf
= current_buffer
;
7293 set_buffer_internal_1 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
7294 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
7295 frame_title_ptr
= frame_title_buf
;
7296 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
7297 NULL
, DEFAULT_FACE_ID
);
7298 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
7299 len
= frame_title_ptr
- frame_title_buf
;
7300 frame_title_ptr
= NULL
;
7301 set_buffer_internal_1 (obuf
);
7303 /* Set the title only if it's changed. This avoids consing in
7304 the common case where it hasn't. (If it turns out that we've
7305 already wasted too much time by walking through the list with
7306 display_mode_element, then we might need to optimize at a
7307 higher level than this.) */
7308 if (! STRINGP (f
->name
)
7309 || SBYTES (f
->name
) != len
7310 || bcmp (frame_title_buf
, SDATA (f
->name
), len
) != 0)
7311 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
7315 #endif /* not HAVE_WINDOW_SYSTEM */
7320 /***********************************************************************
7322 ***********************************************************************/
7325 /* Prepare for redisplay by updating menu-bar item lists when
7326 appropriate. This can call eval. */
7329 prepare_menu_bars ()
7332 struct gcpro gcpro1
, gcpro2
;
7334 Lisp_Object tooltip_frame
;
7336 #ifdef HAVE_WINDOW_SYSTEM
7337 tooltip_frame
= tip_frame
;
7339 tooltip_frame
= Qnil
;
7342 /* Update all frame titles based on their buffer names, etc. We do
7343 this before the menu bars so that the buffer-menu will show the
7344 up-to-date frame titles. */
7345 #ifdef HAVE_WINDOW_SYSTEM
7346 if (windows_or_buffers_changed
|| update_mode_lines
)
7348 Lisp_Object tail
, frame
;
7350 FOR_EACH_FRAME (tail
, frame
)
7353 if (!EQ (frame
, tooltip_frame
)
7354 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
7355 x_consider_frame_title (frame
);
7358 #endif /* HAVE_WINDOW_SYSTEM */
7360 /* Update the menu bar item lists, if appropriate. This has to be
7361 done before any actual redisplay or generation of display lines. */
7362 all_windows
= (update_mode_lines
7363 || buffer_shared
> 1
7364 || windows_or_buffers_changed
);
7367 Lisp_Object tail
, frame
;
7368 int count
= SPECPDL_INDEX ();
7370 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
7372 FOR_EACH_FRAME (tail
, frame
)
7376 /* Ignore tooltip frame. */
7377 if (EQ (frame
, tooltip_frame
))
7380 /* If a window on this frame changed size, report that to
7381 the user and clear the size-change flag. */
7382 if (FRAME_WINDOW_SIZES_CHANGED (f
))
7384 Lisp_Object functions
;
7386 /* Clear flag first in case we get an error below. */
7387 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
7388 functions
= Vwindow_size_change_functions
;
7389 GCPRO2 (tail
, functions
);
7391 while (CONSP (functions
))
7393 call1 (XCAR (functions
), frame
);
7394 functions
= XCDR (functions
);
7400 update_menu_bar (f
, 0);
7401 #ifdef HAVE_WINDOW_SYSTEM
7402 update_tool_bar (f
, 0);
7407 unbind_to (count
, Qnil
);
7411 struct frame
*sf
= SELECTED_FRAME ();
7412 update_menu_bar (sf
, 1);
7413 #ifdef HAVE_WINDOW_SYSTEM
7414 update_tool_bar (sf
, 1);
7418 /* Motif needs this. See comment in xmenu.c. Turn it off when
7419 pending_menu_activation is not defined. */
7420 #ifdef USE_X_TOOLKIT
7421 pending_menu_activation
= 0;
7426 /* Update the menu bar item list for frame F. This has to be done
7427 before we start to fill in any display lines, because it can call
7430 If SAVE_MATCH_DATA is non-zero, we must save and restore it here. */
7433 update_menu_bar (f
, save_match_data
)
7435 int save_match_data
;
7438 register struct window
*w
;
7440 /* If called recursively during a menu update, do nothing. This can
7441 happen when, for instance, an activate-menubar-hook causes a
7443 if (inhibit_menubar_update
)
7446 window
= FRAME_SELECTED_WINDOW (f
);
7447 w
= XWINDOW (window
);
7449 #if 0 /* The if statement below this if statement used to include the
7450 condition !NILP (w->update_mode_line), rather than using
7451 update_mode_lines directly, and this if statement may have
7452 been added to make that condition work. Now the if
7453 statement below matches its comment, this isn't needed. */
7454 if (update_mode_lines
)
7455 w
->update_mode_line
= Qt
;
7458 if (FRAME_WINDOW_P (f
)
7460 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
7461 FRAME_EXTERNAL_MENU_BAR (f
)
7463 FRAME_MENU_BAR_LINES (f
) > 0
7465 : FRAME_MENU_BAR_LINES (f
) > 0)
7467 /* If the user has switched buffers or windows, we need to
7468 recompute to reflect the new bindings. But we'll
7469 recompute when update_mode_lines is set too; that means
7470 that people can use force-mode-line-update to request
7471 that the menu bar be recomputed. The adverse effect on
7472 the rest of the redisplay algorithm is about the same as
7473 windows_or_buffers_changed anyway. */
7474 if (windows_or_buffers_changed
7475 /* This used to test w->update_mode_line, but we believe
7476 there is no need to recompute the menu in that case. */
7477 || update_mode_lines
7478 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
7479 < BUF_MODIFF (XBUFFER (w
->buffer
)))
7480 != !NILP (w
->last_had_star
))
7481 || ((!NILP (Vtransient_mark_mode
)
7482 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
7483 != !NILP (w
->region_showing
)))
7485 struct buffer
*prev
= current_buffer
;
7486 int count
= SPECPDL_INDEX ();
7488 specbind (Qinhibit_menubar_update
, Qt
);
7490 set_buffer_internal_1 (XBUFFER (w
->buffer
));
7491 if (save_match_data
)
7492 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
7493 if (NILP (Voverriding_local_map_menu_flag
))
7495 specbind (Qoverriding_terminal_local_map
, Qnil
);
7496 specbind (Qoverriding_local_map
, Qnil
);
7499 /* Run the Lucid hook. */
7500 safe_run_hooks (Qactivate_menubar_hook
);
7502 /* If it has changed current-menubar from previous value,
7503 really recompute the menu-bar from the value. */
7504 if (! NILP (Vlucid_menu_bar_dirty_flag
))
7505 call0 (Qrecompute_lucid_menubar
);
7507 safe_run_hooks (Qmenu_bar_update_hook
);
7508 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
7510 /* Redisplay the menu bar in case we changed it. */
7511 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
7512 if (FRAME_WINDOW_P (f
)
7513 #if defined (MAC_OS)
7514 /* All frames on Mac OS share the same menubar. So only the
7515 selected frame should be allowed to set it. */
7516 && f
== SELECTED_FRAME ()
7519 set_frame_menubar (f
, 0, 0);
7521 /* On a terminal screen, the menu bar is an ordinary screen
7522 line, and this makes it get updated. */
7523 w
->update_mode_line
= Qt
;
7524 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
7525 /* In the non-toolkit version, the menu bar is an ordinary screen
7526 line, and this makes it get updated. */
7527 w
->update_mode_line
= Qt
;
7528 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
7530 unbind_to (count
, Qnil
);
7531 set_buffer_internal_1 (prev
);
7538 /***********************************************************************
7540 ***********************************************************************/
7542 #ifdef HAVE_WINDOW_SYSTEM
7544 /* Update the tool-bar item list for frame F. This has to be done
7545 before we start to fill in any display lines. Called from
7546 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
7547 and restore it here. */
7550 update_tool_bar (f
, save_match_data
)
7552 int save_match_data
;
7554 if (WINDOWP (f
->tool_bar_window
)
7555 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
) > 0)
7560 window
= FRAME_SELECTED_WINDOW (f
);
7561 w
= XWINDOW (window
);
7563 /* If the user has switched buffers or windows, we need to
7564 recompute to reflect the new bindings. But we'll
7565 recompute when update_mode_lines is set too; that means
7566 that people can use force-mode-line-update to request
7567 that the menu bar be recomputed. The adverse effect on
7568 the rest of the redisplay algorithm is about the same as
7569 windows_or_buffers_changed anyway. */
7570 if (windows_or_buffers_changed
7571 || !NILP (w
->update_mode_line
)
7572 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
7573 < BUF_MODIFF (XBUFFER (w
->buffer
)))
7574 != !NILP (w
->last_had_star
))
7575 || ((!NILP (Vtransient_mark_mode
)
7576 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
7577 != !NILP (w
->region_showing
)))
7579 struct buffer
*prev
= current_buffer
;
7580 int count
= SPECPDL_INDEX ();
7582 /* Set current_buffer to the buffer of the selected
7583 window of the frame, so that we get the right local
7585 set_buffer_internal_1 (XBUFFER (w
->buffer
));
7587 /* Save match data, if we must. */
7588 if (save_match_data
)
7589 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
7591 /* Make sure that we don't accidentally use bogus keymaps. */
7592 if (NILP (Voverriding_local_map_menu_flag
))
7594 specbind (Qoverriding_terminal_local_map
, Qnil
);
7595 specbind (Qoverriding_local_map
, Qnil
);
7598 /* Build desired tool-bar items from keymaps. */
7600 = tool_bar_items (f
->tool_bar_items
, &f
->n_tool_bar_items
);
7602 /* Redisplay the tool-bar in case we changed it. */
7603 w
->update_mode_line
= Qt
;
7605 unbind_to (count
, Qnil
);
7606 set_buffer_internal_1 (prev
);
7612 /* Set F->desired_tool_bar_string to a Lisp string representing frame
7613 F's desired tool-bar contents. F->tool_bar_items must have
7614 been set up previously by calling prepare_menu_bars. */
7617 build_desired_tool_bar_string (f
)
7620 int i
, size
, size_needed
;
7621 struct gcpro gcpro1
, gcpro2
, gcpro3
;
7622 Lisp_Object image
, plist
, props
;
7624 image
= plist
= props
= Qnil
;
7625 GCPRO3 (image
, plist
, props
);
7627 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
7628 Otherwise, make a new string. */
7630 /* The size of the string we might be able to reuse. */
7631 size
= (STRINGP (f
->desired_tool_bar_string
)
7632 ? SCHARS (f
->desired_tool_bar_string
)
7635 /* We need one space in the string for each image. */
7636 size_needed
= f
->n_tool_bar_items
;
7638 /* Reuse f->desired_tool_bar_string, if possible. */
7639 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
7640 f
->desired_tool_bar_string
= Fmake_string (make_number (size_needed
),
7644 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
7645 Fremove_text_properties (make_number (0), make_number (size
),
7646 props
, f
->desired_tool_bar_string
);
7649 /* Put a `display' property on the string for the images to display,
7650 put a `menu_item' property on tool-bar items with a value that
7651 is the index of the item in F's tool-bar item vector. */
7652 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
7654 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
7656 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7657 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7658 int hmargin
, vmargin
, relief
, idx
, end
;
7659 extern Lisp_Object QCrelief
, QCmargin
, QCconversion
, Qimage
;
7661 /* If image is a vector, choose the image according to the
7663 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
7664 if (VECTORP (image
))
7668 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
7669 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
7672 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
7673 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
7675 xassert (ASIZE (image
) >= idx
);
7676 image
= AREF (image
, idx
);
7681 /* Ignore invalid image specifications. */
7682 if (!valid_image_p (image
))
7685 /* Display the tool-bar button pressed, or depressed. */
7686 plist
= Fcopy_sequence (XCDR (image
));
7688 /* Compute margin and relief to draw. */
7689 relief
= (tool_bar_button_relief
>= 0
7690 ? tool_bar_button_relief
7691 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
7692 hmargin
= vmargin
= relief
;
7694 if (INTEGERP (Vtool_bar_button_margin
)
7695 && XINT (Vtool_bar_button_margin
) > 0)
7697 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
7698 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
7700 else if (CONSP (Vtool_bar_button_margin
))
7702 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
7703 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
7704 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
7706 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
7707 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
7708 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
7711 if (auto_raise_tool_bar_buttons_p
)
7713 /* Add a `:relief' property to the image spec if the item is
7717 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
7724 /* If image is selected, display it pressed, i.e. with a
7725 negative relief. If it's not selected, display it with a
7727 plist
= Fplist_put (plist
, QCrelief
,
7729 ? make_number (-relief
)
7730 : make_number (relief
)));
7735 /* Put a margin around the image. */
7736 if (hmargin
|| vmargin
)
7738 if (hmargin
== vmargin
)
7739 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
7741 plist
= Fplist_put (plist
, QCmargin
,
7742 Fcons (make_number (hmargin
),
7743 make_number (vmargin
)));
7746 /* If button is not enabled, and we don't have special images
7747 for the disabled state, make the image appear disabled by
7748 applying an appropriate algorithm to it. */
7749 if (!enabled_p
&& idx
< 0)
7750 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
7752 /* Put a `display' text property on the string for the image to
7753 display. Put a `menu-item' property on the string that gives
7754 the start of this item's properties in the tool-bar items
7756 image
= Fcons (Qimage
, plist
);
7757 props
= list4 (Qdisplay
, image
,
7758 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
7760 /* Let the last image hide all remaining spaces in the tool bar
7761 string. The string can be longer than needed when we reuse a
7763 if (i
+ 1 == f
->n_tool_bar_items
)
7764 end
= SCHARS (f
->desired_tool_bar_string
);
7767 Fadd_text_properties (make_number (i
), make_number (end
),
7768 props
, f
->desired_tool_bar_string
);
7776 /* Display one line of the tool-bar of frame IT->f. */
7779 display_tool_bar_line (it
)
7782 struct glyph_row
*row
= it
->glyph_row
;
7783 int max_x
= it
->last_visible_x
;
7786 prepare_desired_row (row
);
7787 row
->y
= it
->current_y
;
7789 /* Note that this isn't made use of if the face hasn't a box,
7790 so there's no need to check the face here. */
7791 it
->start_of_box_run_p
= 1;
7793 while (it
->current_x
< max_x
)
7795 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
7797 /* Get the next display element. */
7798 if (!get_next_display_element (it
))
7801 /* Produce glyphs. */
7802 x_before
= it
->current_x
;
7803 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
7804 PRODUCE_GLYPHS (it
);
7806 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
7811 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
7813 if (x
+ glyph
->pixel_width
> max_x
)
7815 /* Glyph doesn't fit on line. */
7816 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
7822 x
+= glyph
->pixel_width
;
7826 /* Stop at line ends. */
7827 if (ITERATOR_AT_END_OF_LINE_P (it
))
7830 set_iterator_to_next (it
, 1);
7835 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
7836 extend_face_to_end_of_line (it
);
7837 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
7838 last
->right_box_line_p
= 1;
7839 if (last
== row
->glyphs
[TEXT_AREA
])
7840 last
->left_box_line_p
= 1;
7841 compute_line_metrics (it
);
7843 /* If line is empty, make it occupy the rest of the tool-bar. */
7844 if (!row
->displays_text_p
)
7846 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
7847 row
->ascent
= row
->phys_ascent
= 0;
7850 row
->full_width_p
= 1;
7851 row
->continued_p
= 0;
7852 row
->truncated_on_left_p
= 0;
7853 row
->truncated_on_right_p
= 0;
7855 it
->current_x
= it
->hpos
= 0;
7856 it
->current_y
+= row
->height
;
7862 /* Value is the number of screen lines needed to make all tool-bar
7863 items of frame F visible. */
7866 tool_bar_lines_needed (f
)
7869 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7872 /* Initialize an iterator for iteration over
7873 F->desired_tool_bar_string in the tool-bar window of frame F. */
7874 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
7875 it
.first_visible_x
= 0;
7876 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
7877 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
7879 while (!ITERATOR_AT_END_P (&it
))
7881 it
.glyph_row
= w
->desired_matrix
->rows
;
7882 clear_glyph_row (it
.glyph_row
);
7883 display_tool_bar_line (&it
);
7886 return (it
.current_y
+ CANON_Y_UNIT (f
) - 1) / CANON_Y_UNIT (f
);
7890 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
7892 doc
: /* Return the number of lines occupied by the tool bar of FRAME. */)
7901 frame
= selected_frame
;
7903 CHECK_FRAME (frame
);
7906 if (WINDOWP (f
->tool_bar_window
)
7907 || (w
= XWINDOW (f
->tool_bar_window
),
7908 XFASTINT (w
->height
) > 0))
7910 update_tool_bar (f
, 1);
7911 if (f
->n_tool_bar_items
)
7913 build_desired_tool_bar_string (f
);
7914 nlines
= tool_bar_lines_needed (f
);
7918 return make_number (nlines
);
7922 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
7923 height should be changed. */
7926 redisplay_tool_bar (f
)
7931 struct glyph_row
*row
;
7932 int change_height_p
= 0;
7934 /* If frame hasn't a tool-bar window or if it is zero-height, don't
7935 do anything. This means you must start with tool-bar-lines
7936 non-zero to get the auto-sizing effect. Or in other words, you
7937 can turn off tool-bars by specifying tool-bar-lines zero. */
7938 if (!WINDOWP (f
->tool_bar_window
)
7939 || (w
= XWINDOW (f
->tool_bar_window
),
7940 XFASTINT (w
->height
) == 0))
7943 /* Set up an iterator for the tool-bar window. */
7944 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
7945 it
.first_visible_x
= 0;
7946 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
7949 /* Build a string that represents the contents of the tool-bar. */
7950 build_desired_tool_bar_string (f
);
7951 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
7953 /* Display as many lines as needed to display all tool-bar items. */
7954 while (it
.current_y
< it
.last_visible_y
)
7955 display_tool_bar_line (&it
);
7957 /* It doesn't make much sense to try scrolling in the tool-bar
7958 window, so don't do it. */
7959 w
->desired_matrix
->no_scrolling_p
= 1;
7960 w
->must_be_updated_p
= 1;
7962 if (auto_resize_tool_bars_p
)
7966 /* If we couldn't display everything, change the tool-bar's
7968 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
)
7969 change_height_p
= 1;
7971 /* If there are blank lines at the end, except for a partially
7972 visible blank line at the end that is smaller than
7973 CANON_Y_UNIT, change the tool-bar's height. */
7974 row
= it
.glyph_row
- 1;
7975 if (!row
->displays_text_p
7976 && row
->height
>= CANON_Y_UNIT (f
))
7977 change_height_p
= 1;
7979 /* If row displays tool-bar items, but is partially visible,
7980 change the tool-bar's height. */
7981 if (row
->displays_text_p
7982 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
)
7983 change_height_p
= 1;
7985 /* Resize windows as needed by changing the `tool-bar-lines'
7988 && (nlines
= tool_bar_lines_needed (f
),
7989 nlines
!= XFASTINT (w
->height
)))
7991 extern Lisp_Object Qtool_bar_lines
;
7993 int old_height
= XFASTINT (w
->height
);
7995 XSETFRAME (frame
, f
);
7996 clear_glyph_matrix (w
->desired_matrix
);
7997 Fmodify_frame_parameters (frame
,
7998 Fcons (Fcons (Qtool_bar_lines
,
7999 make_number (nlines
)),
8001 if (XFASTINT (w
->height
) != old_height
)
8002 fonts_changed_p
= 1;
8006 return change_height_p
;
8010 /* Get information about the tool-bar item which is displayed in GLYPH
8011 on frame F. Return in *PROP_IDX the index where tool-bar item
8012 properties start in F->tool_bar_items. Value is zero if
8013 GLYPH doesn't display a tool-bar item. */
8016 tool_bar_item_info (f
, glyph
, prop_idx
)
8018 struct glyph
*glyph
;
8025 /* This function can be called asynchronously, which means we must
8026 exclude any possibility that Fget_text_property signals an
8028 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
8029 charpos
= max (0, charpos
);
8031 /* Get the text property `menu-item' at pos. The value of that
8032 property is the start index of this item's properties in
8033 F->tool_bar_items. */
8034 prop
= Fget_text_property (make_number (charpos
),
8035 Qmenu_item
, f
->current_tool_bar_string
);
8036 if (INTEGERP (prop
))
8038 *prop_idx
= XINT (prop
);
8047 #endif /* HAVE_WINDOW_SYSTEM */
8051 /************************************************************************
8052 Horizontal scrolling
8053 ************************************************************************/
8055 static int hscroll_window_tree
P_ ((Lisp_Object
));
8056 static int hscroll_windows
P_ ((Lisp_Object
));
8058 /* For all leaf windows in the window tree rooted at WINDOW, set their
8059 hscroll value so that PT is (i) visible in the window, and (ii) so
8060 that it is not within a certain margin at the window's left and
8061 right border. Value is non-zero if any window's hscroll has been
8065 hscroll_window_tree (window
)
8068 int hscrolled_p
= 0;
8069 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
8070 int hscroll_step_abs
= 0;
8071 double hscroll_step_rel
= 0;
8073 if (hscroll_relative_p
)
8075 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
8076 if (hscroll_step_rel
< 0)
8078 hscroll_relative_p
= 0;
8079 hscroll_step_abs
= 0;
8082 else if (INTEGERP (Vhscroll_step
))
8084 hscroll_step_abs
= XINT (Vhscroll_step
);
8085 if (hscroll_step_abs
< 0)
8086 hscroll_step_abs
= 0;
8089 hscroll_step_abs
= 0;
8091 while (WINDOWP (window
))
8093 struct window
*w
= XWINDOW (window
);
8095 if (WINDOWP (w
->hchild
))
8096 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
8097 else if (WINDOWP (w
->vchild
))
8098 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
8099 else if (w
->cursor
.vpos
>= 0)
8101 int h_margin
, text_area_x
, text_area_y
;
8102 int text_area_width
, text_area_height
;
8103 struct glyph_row
*current_cursor_row
8104 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
8105 struct glyph_row
*desired_cursor_row
8106 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
8107 struct glyph_row
*cursor_row
8108 = (desired_cursor_row
->enabled_p
8109 ? desired_cursor_row
8110 : current_cursor_row
);
8112 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
,
8113 &text_area_width
, &text_area_height
);
8115 /* Scroll when cursor is inside this scroll margin. */
8116 h_margin
= hscroll_margin
* CANON_X_UNIT (XFRAME (w
->frame
));
8118 if ((XFASTINT (w
->hscroll
)
8119 && w
->cursor
.x
<= h_margin
)
8120 || (cursor_row
->enabled_p
8121 && cursor_row
->truncated_on_right_p
8122 && (w
->cursor
.x
>= text_area_width
- h_margin
)))
8126 struct buffer
*saved_current_buffer
;
8130 /* Find point in a display of infinite width. */
8131 saved_current_buffer
= current_buffer
;
8132 current_buffer
= XBUFFER (w
->buffer
);
8134 if (w
== XWINDOW (selected_window
))
8135 pt
= BUF_PT (current_buffer
);
8138 pt
= marker_position (w
->pointm
);
8139 pt
= max (BEGV
, pt
);
8143 /* Move iterator to pt starting at cursor_row->start in
8144 a line with infinite width. */
8145 init_to_row_start (&it
, w
, cursor_row
);
8146 it
.last_visible_x
= INFINITY
;
8147 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
8148 current_buffer
= saved_current_buffer
;
8150 /* Position cursor in window. */
8151 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
8152 hscroll
= max (0, it
.current_x
- text_area_width
/ 2)
8153 / CANON_X_UNIT (it
.f
);
8154 else if (w
->cursor
.x
>= text_area_width
- h_margin
)
8156 if (hscroll_relative_p
)
8157 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
8160 wanted_x
= text_area_width
8161 - hscroll_step_abs
* CANON_X_UNIT (it
.f
)
8164 = max (0, it
.current_x
- wanted_x
) / CANON_X_UNIT (it
.f
);
8168 if (hscroll_relative_p
)
8169 wanted_x
= text_area_width
* hscroll_step_rel
8172 wanted_x
= hscroll_step_abs
* CANON_X_UNIT (it
.f
)
8175 = max (0, it
.current_x
- wanted_x
) / CANON_X_UNIT (it
.f
);
8177 hscroll
= max (hscroll
, XFASTINT (w
->min_hscroll
));
8179 /* Don't call Fset_window_hscroll if value hasn't
8180 changed because it will prevent redisplay
8182 if (XFASTINT (w
->hscroll
) != hscroll
)
8184 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
8185 w
->hscroll
= make_number (hscroll
);
8194 /* Value is non-zero if hscroll of any leaf window has been changed. */
8199 /* Set hscroll so that cursor is visible and not inside horizontal
8200 scroll margins for all windows in the tree rooted at WINDOW. See
8201 also hscroll_window_tree above. Value is non-zero if any window's
8202 hscroll has been changed. If it has, desired matrices on the frame
8203 of WINDOW are cleared. */
8206 hscroll_windows (window
)
8211 if (automatic_hscrolling_p
)
8213 hscrolled_p
= hscroll_window_tree (window
);
8215 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
8224 /************************************************************************
8226 ************************************************************************/
8228 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
8229 to a non-zero value. This is sometimes handy to have in a debugger
8234 /* First and last unchanged row for try_window_id. */
8236 int debug_first_unchanged_at_end_vpos
;
8237 int debug_last_unchanged_at_beg_vpos
;
8239 /* Delta vpos and y. */
8241 int debug_dvpos
, debug_dy
;
8243 /* Delta in characters and bytes for try_window_id. */
8245 int debug_delta
, debug_delta_bytes
;
8247 /* Values of window_end_pos and window_end_vpos at the end of
8250 EMACS_INT debug_end_pos
, debug_end_vpos
;
8252 /* Append a string to W->desired_matrix->method. FMT is a printf
8253 format string. A1...A9 are a supplement for a variable-length
8254 argument list. If trace_redisplay_p is non-zero also printf the
8255 resulting string to stderr. */
8258 debug_method_add (w
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
8261 int a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
;
8264 char *method
= w
->desired_matrix
->method
;
8265 int len
= strlen (method
);
8266 int size
= sizeof w
->desired_matrix
->method
;
8267 int remaining
= size
- len
- 1;
8269 sprintf (buffer
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
8270 if (len
&& remaining
)
8276 strncpy (method
+ len
, buffer
, remaining
);
8278 if (trace_redisplay_p
)
8279 fprintf (stderr
, "%p (%s): %s\n",
8281 ((BUFFERP (w
->buffer
)
8282 && STRINGP (XBUFFER (w
->buffer
)->name
))
8283 ? (char *) SDATA (XBUFFER (w
->buffer
)->name
)
8288 #endif /* GLYPH_DEBUG */
8291 /* This counter is used to clear the face cache every once in a while
8292 in redisplay_internal. It is incremented for each redisplay.
8293 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
8296 #define CLEAR_FACE_CACHE_COUNT 500
8297 static int clear_face_cache_count
;
8299 /* Record the previous terminal frame we displayed. */
8301 static struct frame
*previous_terminal_frame
;
8303 /* Non-zero while redisplay_internal is in progress. */
8308 /* Value is non-zero if all changes in window W, which displays
8309 current_buffer, are in the text between START and END. START is a
8310 buffer position, END is given as a distance from Z. Used in
8311 redisplay_internal for display optimization. */
8314 text_outside_line_unchanged_p (w
, start
, end
)
8318 int unchanged_p
= 1;
8320 /* If text or overlays have changed, see where. */
8321 if (XFASTINT (w
->last_modified
) < MODIFF
8322 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
8324 /* Gap in the line? */
8325 if (GPT
< start
|| Z
- GPT
< end
)
8328 /* Changes start in front of the line, or end after it? */
8330 && (BEG_UNCHANGED
< start
- 1
8331 || END_UNCHANGED
< end
))
8334 /* If selective display, can't optimize if changes start at the
8335 beginning of the line. */
8337 && INTEGERP (current_buffer
->selective_display
)
8338 && XINT (current_buffer
->selective_display
) > 0
8339 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
8342 /* If there are overlays at the start or end of the line, these
8343 may have overlay strings with newlines in them. A change at
8344 START, for instance, may actually concern the display of such
8345 overlay strings as well, and they are displayed on different
8346 lines. So, quickly rule out this case. (For the future, it
8347 might be desirable to implement something more telling than
8348 just BEG/END_UNCHANGED.) */
8351 if (BEG
+ BEG_UNCHANGED
== start
8352 && overlay_touches_p (start
))
8354 if (END_UNCHANGED
== end
8355 && overlay_touches_p (Z
- end
))
8364 /* Do a frame update, taking possible shortcuts into account. This is
8365 the main external entry point for redisplay.
8367 If the last redisplay displayed an echo area message and that message
8368 is no longer requested, we clear the echo area or bring back the
8369 mini-buffer if that is in use. */
8374 redisplay_internal (0);
8378 /* Return 1 if point moved out of or into a composition. Otherwise
8379 return 0. PREV_BUF and PREV_PT are the last point buffer and
8380 position. BUF and PT are the current point buffer and position. */
8383 check_point_in_composition (prev_buf
, prev_pt
, buf
, pt
)
8384 struct buffer
*prev_buf
, *buf
;
8391 XSETBUFFER (buffer
, buf
);
8392 /* Check a composition at the last point if point moved within the
8394 if (prev_buf
== buf
)
8397 /* Point didn't move. */
8400 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
8401 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
8402 && COMPOSITION_VALID_P (start
, end
, prop
)
8403 && start
< prev_pt
&& end
> prev_pt
)
8404 /* The last point was within the composition. Return 1 iff
8405 point moved out of the composition. */
8406 return (pt
<= start
|| pt
>= end
);
8409 /* Check a composition at the current point. */
8410 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
8411 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
8412 && COMPOSITION_VALID_P (start
, end
, prop
)
8413 && start
< pt
&& end
> pt
);
8417 /* Reconsider the setting of B->clip_changed which is displayed
8421 reconsider_clip_changes (w
, b
)
8426 && !NILP (w
->window_end_valid
)
8427 && w
->current_matrix
->buffer
== b
8428 && w
->current_matrix
->zv
== BUF_ZV (b
)
8429 && w
->current_matrix
->begv
== BUF_BEGV (b
))
8430 b
->clip_changed
= 0;
8432 /* If display wasn't paused, and W is not a tool bar window, see if
8433 point has been moved into or out of a composition. In that case,
8434 we set b->clip_changed to 1 to force updating the screen. If
8435 b->clip_changed has already been set to 1, we can skip this
8437 if (!b
->clip_changed
8438 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
8442 if (w
== XWINDOW (selected_window
))
8443 pt
= BUF_PT (current_buffer
);
8445 pt
= marker_position (w
->pointm
);
8447 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
8448 || pt
!= XINT (w
->last_point
))
8449 && check_point_in_composition (w
->current_matrix
->buffer
,
8450 XINT (w
->last_point
),
8451 XBUFFER (w
->buffer
), pt
))
8452 b
->clip_changed
= 1;
8457 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay is not in
8458 response to any user action; therefore, we should preserve the echo
8459 area. (Actually, our caller does that job.) Perhaps in the future
8460 avoid recentering windows if it is not necessary; currently that
8461 causes some problems. */
8464 redisplay_internal (preserve_echo_area
)
8465 int preserve_echo_area
;
8467 struct window
*w
= XWINDOW (selected_window
);
8468 struct frame
*f
= XFRAME (w
->frame
);
8470 int must_finish
= 0;
8471 struct text_pos tlbufpos
, tlendpos
;
8472 int number_of_visible_frames
;
8474 struct frame
*sf
= SELECTED_FRAME ();
8476 /* Non-zero means redisplay has to consider all windows on all
8477 frames. Zero means, only selected_window is considered. */
8478 int consider_all_windows_p
;
8480 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
8482 /* No redisplay if running in batch mode or frame is not yet fully
8483 initialized, or redisplay is explicitly turned off by setting
8484 Vinhibit_redisplay. */
8486 || !NILP (Vinhibit_redisplay
)
8487 || !f
->glyphs_initialized_p
)
8490 /* The flag redisplay_performed_directly_p is set by
8491 direct_output_for_insert when it already did the whole screen
8492 update necessary. */
8493 if (redisplay_performed_directly_p
)
8495 redisplay_performed_directly_p
= 0;
8496 if (!hscroll_windows (selected_window
))
8500 #ifdef USE_X_TOOLKIT
8501 if (popup_activated ())
8505 /* I don't think this happens but let's be paranoid. */
8509 /* Record a function that resets redisplaying_p to its old value
8510 when we leave this function. */
8511 count
= SPECPDL_INDEX ();
8512 record_unwind_protect (unwind_redisplay
, make_number (redisplaying_p
));
8517 reconsider_clip_changes (w
, current_buffer
);
8519 /* If new fonts have been loaded that make a glyph matrix adjustment
8520 necessary, do it. */
8521 if (fonts_changed_p
)
8523 adjust_glyphs (NULL
);
8524 ++windows_or_buffers_changed
;
8525 fonts_changed_p
= 0;
8528 /* If face_change_count is non-zero, init_iterator will free all
8529 realized faces, which includes the faces referenced from current
8530 matrices. So, we can't reuse current matrices in this case. */
8531 if (face_change_count
)
8532 ++windows_or_buffers_changed
;
8534 if (! FRAME_WINDOW_P (sf
)
8535 && previous_terminal_frame
!= sf
)
8537 /* Since frames on an ASCII terminal share the same display
8538 area, displaying a different frame means redisplay the whole
8540 windows_or_buffers_changed
++;
8541 SET_FRAME_GARBAGED (sf
);
8542 XSETFRAME (Vterminal_frame
, sf
);
8544 previous_terminal_frame
= sf
;
8546 /* Set the visible flags for all frames. Do this before checking
8547 for resized or garbaged frames; they want to know if their frames
8548 are visible. See the comment in frame.h for
8549 FRAME_SAMPLE_VISIBILITY. */
8551 Lisp_Object tail
, frame
;
8553 number_of_visible_frames
= 0;
8555 FOR_EACH_FRAME (tail
, frame
)
8557 struct frame
*f
= XFRAME (frame
);
8559 FRAME_SAMPLE_VISIBILITY (f
);
8560 if (FRAME_VISIBLE_P (f
))
8561 ++number_of_visible_frames
;
8562 clear_desired_matrices (f
);
8566 /* Notice any pending interrupt request to change frame size. */
8567 do_pending_window_change (1);
8569 /* Clear frames marked as garbaged. */
8571 clear_garbaged_frames ();
8573 /* Build menubar and tool-bar items. */
8574 prepare_menu_bars ();
8576 if (windows_or_buffers_changed
)
8577 update_mode_lines
++;
8579 /* Detect case that we need to write or remove a star in the mode line. */
8580 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
8582 w
->update_mode_line
= Qt
;
8583 if (buffer_shared
> 1)
8584 update_mode_lines
++;
8587 /* If %c is in the mode line, update it if needed. */
8588 if (!NILP (w
->column_number_displayed
)
8589 /* This alternative quickly identifies a common case
8590 where no change is needed. */
8591 && !(PT
== XFASTINT (w
->last_point
)
8592 && XFASTINT (w
->last_modified
) >= MODIFF
8593 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
8594 && (XFASTINT (w
->column_number_displayed
)
8595 != (int) current_column ())) /* iftc */
8596 w
->update_mode_line
= Qt
;
8598 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
8600 /* The variable buffer_shared is set in redisplay_window and
8601 indicates that we redisplay a buffer in different windows. See
8603 consider_all_windows_p
= (update_mode_lines
|| buffer_shared
> 1
8604 || cursor_type_changed
);
8606 /* If specs for an arrow have changed, do thorough redisplay
8607 to ensure we remove any arrow that should no longer exist. */
8608 if (! EQ (COERCE_MARKER (Voverlay_arrow_position
), last_arrow_position
)
8609 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
8610 consider_all_windows_p
= windows_or_buffers_changed
= 1;
8612 /* Normally the message* functions will have already displayed and
8613 updated the echo area, but the frame may have been trashed, or
8614 the update may have been preempted, so display the echo area
8615 again here. Checking message_cleared_p captures the case that
8616 the echo area should be cleared. */
8617 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
8618 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
8619 || (message_cleared_p
8620 && minibuf_level
== 0
8621 /* If the mini-window is currently selected, this means the
8622 echo-area doesn't show through. */
8623 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
8625 int window_height_changed_p
= echo_area_display (0);
8628 /* If we don't display the current message, don't clear the
8629 message_cleared_p flag, because, if we did, we wouldn't clear
8630 the echo area in the next redisplay which doesn't preserve
8632 if (!display_last_displayed_message_p
)
8633 message_cleared_p
= 0;
8635 if (fonts_changed_p
)
8637 else if (window_height_changed_p
)
8639 consider_all_windows_p
= 1;
8640 ++update_mode_lines
;
8641 ++windows_or_buffers_changed
;
8643 /* If window configuration was changed, frames may have been
8644 marked garbaged. Clear them or we will experience
8645 surprises wrt scrolling. */
8647 clear_garbaged_frames ();
8650 else if (EQ (selected_window
, minibuf_window
)
8651 && (current_buffer
->clip_changed
8652 || XFASTINT (w
->last_modified
) < MODIFF
8653 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
8654 && resize_mini_window (w
, 0))
8656 /* Resized active mini-window to fit the size of what it is
8657 showing if its contents might have changed. */
8659 consider_all_windows_p
= 1;
8660 ++windows_or_buffers_changed
;
8661 ++update_mode_lines
;
8663 /* If window configuration was changed, frames may have been
8664 marked garbaged. Clear them or we will experience
8665 surprises wrt scrolling. */
8667 clear_garbaged_frames ();
8671 /* If showing the region, and mark has changed, we must redisplay
8672 the whole window. The assignment to this_line_start_pos prevents
8673 the optimization directly below this if-statement. */
8674 if (((!NILP (Vtransient_mark_mode
)
8675 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
8676 != !NILP (w
->region_showing
))
8677 || (!NILP (w
->region_showing
)
8678 && !EQ (w
->region_showing
,
8679 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
8680 CHARPOS (this_line_start_pos
) = 0;
8682 /* Optimize the case that only the line containing the cursor in the
8683 selected window has changed. Variables starting with this_ are
8684 set in display_line and record information about the line
8685 containing the cursor. */
8686 tlbufpos
= this_line_start_pos
;
8687 tlendpos
= this_line_end_pos
;
8688 if (!consider_all_windows_p
8689 && CHARPOS (tlbufpos
) > 0
8690 && NILP (w
->update_mode_line
)
8691 && !current_buffer
->clip_changed
8692 && !current_buffer
->prevent_redisplay_optimizations_p
8693 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
8694 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
8695 /* Make sure recorded data applies to current buffer, etc. */
8696 && this_line_buffer
== current_buffer
8697 && current_buffer
== XBUFFER (w
->buffer
)
8698 && NILP (w
->force_start
)
8699 && NILP (w
->optional_new_start
)
8700 /* Point must be on the line that we have info recorded about. */
8701 && PT
>= CHARPOS (tlbufpos
)
8702 && PT
<= Z
- CHARPOS (tlendpos
)
8703 /* All text outside that line, including its final newline,
8704 must be unchanged */
8705 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
8706 CHARPOS (tlendpos
)))
8708 if (CHARPOS (tlbufpos
) > BEGV
8709 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
8710 && (CHARPOS (tlbufpos
) == ZV
8711 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
8712 /* Former continuation line has disappeared by becoming empty */
8714 else if (XFASTINT (w
->last_modified
) < MODIFF
8715 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
8716 || MINI_WINDOW_P (w
))
8718 /* We have to handle the case of continuation around a
8719 wide-column character (See the comment in indent.c around
8722 For instance, in the following case:
8724 -------- Insert --------
8725 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
8726 J_I_ ==> J_I_ `^^' are cursors.
8730 As we have to redraw the line above, we should goto cancel. */
8733 int line_height_before
= this_line_pixel_height
;
8735 /* Note that start_display will handle the case that the
8736 line starting at tlbufpos is a continuation lines. */
8737 start_display (&it
, w
, tlbufpos
);
8739 /* Implementation note: It this still necessary? */
8740 if (it
.current_x
!= this_line_start_x
)
8743 TRACE ((stderr
, "trying display optimization 1\n"));
8744 w
->cursor
.vpos
= -1;
8745 overlay_arrow_seen
= 0;
8746 it
.vpos
= this_line_vpos
;
8747 it
.current_y
= this_line_y
;
8748 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
8751 /* If line contains point, is not continued,
8752 and ends at same distance from eob as before, we win */
8753 if (w
->cursor
.vpos
>= 0
8754 /* Line is not continued, otherwise this_line_start_pos
8755 would have been set to 0 in display_line. */
8756 && CHARPOS (this_line_start_pos
)
8757 /* Line ends as before. */
8758 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
8759 /* Line has same height as before. Otherwise other lines
8760 would have to be shifted up or down. */
8761 && this_line_pixel_height
== line_height_before
)
8763 /* If this is not the window's last line, we must adjust
8764 the charstarts of the lines below. */
8765 if (it
.current_y
< it
.last_visible_y
)
8767 struct glyph_row
*row
8768 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
8769 int delta
, delta_bytes
;
8771 if (Z
- CHARPOS (tlendpos
) == ZV
)
8773 /* This line ends at end of (accessible part of)
8774 buffer. There is no newline to count. */
8776 - CHARPOS (tlendpos
)
8777 - MATRIX_ROW_START_CHARPOS (row
));
8778 delta_bytes
= (Z_BYTE
8779 - BYTEPOS (tlendpos
)
8780 - MATRIX_ROW_START_BYTEPOS (row
));
8784 /* This line ends in a newline. Must take
8785 account of the newline and the rest of the
8786 text that follows. */
8788 - CHARPOS (tlendpos
)
8789 - MATRIX_ROW_START_CHARPOS (row
));
8790 delta_bytes
= (Z_BYTE
8791 - BYTEPOS (tlendpos
)
8792 - MATRIX_ROW_START_BYTEPOS (row
));
8795 increment_matrix_positions (w
->current_matrix
,
8797 w
->current_matrix
->nrows
,
8798 delta
, delta_bytes
);
8801 /* If this row displays text now but previously didn't,
8802 or vice versa, w->window_end_vpos may have to be
8804 if ((it
.glyph_row
- 1)->displays_text_p
)
8806 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
8807 XSETINT (w
->window_end_vpos
, this_line_vpos
);
8809 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
8810 && this_line_vpos
> 0)
8811 XSETINT (w
->window_end_vpos
, this_line_vpos
- 1);
8812 w
->window_end_valid
= Qnil
;
8814 /* Update hint: No need to try to scroll in update_window. */
8815 w
->desired_matrix
->no_scrolling_p
= 1;
8818 *w
->desired_matrix
->method
= 0;
8819 debug_method_add (w
, "optimization 1");
8826 else if (/* Cursor position hasn't changed. */
8827 PT
== XFASTINT (w
->last_point
)
8828 /* Make sure the cursor was last displayed
8829 in this window. Otherwise we have to reposition it. */
8830 && 0 <= w
->cursor
.vpos
8831 && XINT (w
->height
) > w
->cursor
.vpos
)
8835 do_pending_window_change (1);
8837 /* We used to always goto end_of_redisplay here, but this
8838 isn't enough if we have a blinking cursor. */
8839 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
8840 goto end_of_redisplay
;
8844 /* If highlighting the region, or if the cursor is in the echo area,
8845 then we can't just move the cursor. */
8846 else if (! (!NILP (Vtransient_mark_mode
)
8847 && !NILP (current_buffer
->mark_active
))
8848 && (EQ (selected_window
, current_buffer
->last_selected_window
)
8849 || highlight_nonselected_windows
)
8850 && NILP (w
->region_showing
)
8851 && NILP (Vshow_trailing_whitespace
)
8852 && !cursor_in_echo_area
)
8855 struct glyph_row
*row
;
8857 /* Skip from tlbufpos to PT and see where it is. Note that
8858 PT may be in invisible text. If so, we will end at the
8859 next visible position. */
8860 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
8861 NULL
, DEFAULT_FACE_ID
);
8862 it
.current_x
= this_line_start_x
;
8863 it
.current_y
= this_line_y
;
8864 it
.vpos
= this_line_vpos
;
8866 /* The call to move_it_to stops in front of PT, but
8867 moves over before-strings. */
8868 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
8870 if (it
.vpos
== this_line_vpos
8871 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
8874 xassert (this_line_vpos
== it
.vpos
);
8875 xassert (this_line_y
== it
.current_y
);
8876 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
8878 *w
->desired_matrix
->method
= 0;
8879 debug_method_add (w
, "optimization 3");
8888 /* Text changed drastically or point moved off of line. */
8889 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
8892 CHARPOS (this_line_start_pos
) = 0;
8893 consider_all_windows_p
|= buffer_shared
> 1;
8894 ++clear_face_cache_count
;
8897 /* Build desired matrices, and update the display. If
8898 consider_all_windows_p is non-zero, do it for all windows on all
8899 frames. Otherwise do it for selected_window, only. */
8901 if (consider_all_windows_p
)
8903 Lisp_Object tail
, frame
;
8904 int i
, n
= 0, size
= 50;
8905 struct frame
**updated
8906 = (struct frame
**) alloca (size
* sizeof *updated
);
8908 /* Clear the face cache eventually. */
8909 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
8911 clear_face_cache (0);
8912 clear_face_cache_count
= 0;
8915 /* Recompute # windows showing selected buffer. This will be
8916 incremented each time such a window is displayed. */
8919 FOR_EACH_FRAME (tail
, frame
)
8921 struct frame
*f
= XFRAME (frame
);
8923 if (FRAME_WINDOW_P (f
) || f
== sf
)
8925 #ifdef HAVE_WINDOW_SYSTEM
8926 if (clear_face_cache_count
% 50 == 0
8927 && FRAME_WINDOW_P (f
))
8928 clear_image_cache (f
, 0);
8929 #endif /* HAVE_WINDOW_SYSTEM */
8931 /* Mark all the scroll bars to be removed; we'll redeem
8932 the ones we want when we redisplay their windows. */
8933 if (condemn_scroll_bars_hook
)
8934 condemn_scroll_bars_hook (f
);
8936 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
8937 redisplay_windows (FRAME_ROOT_WINDOW (f
));
8939 /* Any scroll bars which redisplay_windows should have
8940 nuked should now go away. */
8941 if (judge_scroll_bars_hook
)
8942 judge_scroll_bars_hook (f
);
8944 /* If fonts changed, display again. */
8945 if (fonts_changed_p
)
8948 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
8950 /* See if we have to hscroll. */
8951 if (hscroll_windows (f
->root_window
))
8954 /* Prevent various kinds of signals during display
8955 update. stdio is not robust about handling
8956 signals, which can cause an apparent I/O
8958 if (interrupt_input
)
8962 /* Update the display. */
8963 set_window_update_flags (XWINDOW (f
->root_window
), 1);
8964 pause
|= update_frame (f
, 0, 0);
8970 int nbytes
= size
* sizeof *updated
;
8971 struct frame
**p
= (struct frame
**) alloca (2 * nbytes
);
8972 bcopy (updated
, p
, nbytes
);
8981 /* Do the mark_window_display_accurate after all windows have
8982 been redisplayed because this call resets flags in buffers
8983 which are needed for proper redisplay. */
8984 for (i
= 0; i
< n
; ++i
)
8986 struct frame
*f
= updated
[i
];
8987 mark_window_display_accurate (f
->root_window
, 1);
8988 if (frame_up_to_date_hook
)
8989 frame_up_to_date_hook (f
);
8992 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
8994 Lisp_Object mini_window
;
8995 struct frame
*mini_frame
;
8997 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
8998 /* Use list_of_error, not Qerror, so that
8999 we catch only errors and don't run the debugger. */
9000 internal_condition_case_1 (redisplay_window_1
, selected_window
,
9002 redisplay_window_error
);
9004 /* Compare desired and current matrices, perform output. */
9007 /* If fonts changed, display again. */
9008 if (fonts_changed_p
)
9011 /* Prevent various kinds of signals during display update.
9012 stdio is not robust about handling signals,
9013 which can cause an apparent I/O error. */
9014 if (interrupt_input
)
9018 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
9020 if (hscroll_windows (selected_window
))
9023 XWINDOW (selected_window
)->must_be_updated_p
= 1;
9024 pause
= update_frame (sf
, 0, 0);
9027 /* We may have called echo_area_display at the top of this
9028 function. If the echo area is on another frame, that may
9029 have put text on a frame other than the selected one, so the
9030 above call to update_frame would not have caught it. Catch
9032 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9033 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9035 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
9037 XWINDOW (mini_window
)->must_be_updated_p
= 1;
9038 pause
|= update_frame (mini_frame
, 0, 0);
9039 if (!pause
&& hscroll_windows (mini_window
))
9044 /* If display was paused because of pending input, make sure we do a
9045 thorough update the next time. */
9048 /* Prevent the optimization at the beginning of
9049 redisplay_internal that tries a single-line update of the
9050 line containing the cursor in the selected window. */
9051 CHARPOS (this_line_start_pos
) = 0;
9053 /* Let the overlay arrow be updated the next time. */
9054 if (!NILP (last_arrow_position
))
9056 last_arrow_position
= Qt
;
9057 last_arrow_string
= Qt
;
9060 /* If we pause after scrolling, some rows in the current
9061 matrices of some windows are not valid. */
9062 if (!WINDOW_FULL_WIDTH_P (w
)
9063 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
9064 update_mode_lines
= 1;
9068 if (!consider_all_windows_p
)
9070 /* This has already been done above if
9071 consider_all_windows_p is set. */
9072 mark_window_display_accurate_1 (w
, 1);
9074 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
9075 last_arrow_string
= Voverlay_arrow_string
;
9077 if (frame_up_to_date_hook
!= 0)
9078 frame_up_to_date_hook (sf
);
9081 update_mode_lines
= 0;
9082 windows_or_buffers_changed
= 0;
9083 cursor_type_changed
= 0;
9086 /* Start SIGIO interrupts coming again. Having them off during the
9087 code above makes it less likely one will discard output, but not
9088 impossible, since there might be stuff in the system buffer here.
9089 But it is much hairier to try to do anything about that. */
9090 if (interrupt_input
)
9094 /* If a frame has become visible which was not before, redisplay
9095 again, so that we display it. Expose events for such a frame
9096 (which it gets when becoming visible) don't call the parts of
9097 redisplay constructing glyphs, so simply exposing a frame won't
9098 display anything in this case. So, we have to display these
9099 frames here explicitly. */
9102 Lisp_Object tail
, frame
;
9105 FOR_EACH_FRAME (tail
, frame
)
9107 int this_is_visible
= 0;
9109 if (XFRAME (frame
)->visible
)
9110 this_is_visible
= 1;
9111 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
9112 if (XFRAME (frame
)->visible
)
9113 this_is_visible
= 1;
9115 if (this_is_visible
)
9119 if (new_count
!= number_of_visible_frames
)
9120 windows_or_buffers_changed
++;
9123 /* Change frame size now if a change is pending. */
9124 do_pending_window_change (1);
9126 /* If we just did a pending size change, or have additional
9127 visible frames, redisplay again. */
9128 if (windows_or_buffers_changed
&& !pause
)
9133 unbind_to (count
, Qnil
);
9137 /* Redisplay, but leave alone any recent echo area message unless
9138 another message has been requested in its place.
9140 This is useful in situations where you need to redisplay but no
9141 user action has occurred, making it inappropriate for the message
9142 area to be cleared. See tracking_off and
9143 wait_reading_process_input for examples of these situations.
9145 FROM_WHERE is an integer saying from where this function was
9146 called. This is useful for debugging. */
9149 redisplay_preserve_echo_area (from_where
)
9152 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
9154 if (!NILP (echo_area_buffer
[1]))
9156 /* We have a previously displayed message, but no current
9157 message. Redisplay the previous message. */
9158 display_last_displayed_message_p
= 1;
9159 redisplay_internal (1);
9160 display_last_displayed_message_p
= 0;
9163 redisplay_internal (1);
9167 /* Function registered with record_unwind_protect in
9168 redisplay_internal. Clears the flag indicating that a redisplay is
9172 unwind_redisplay (old_redisplaying_p
)
9173 Lisp_Object old_redisplaying_p
;
9175 redisplaying_p
= XFASTINT (old_redisplaying_p
);
9180 /* Mark the display of window W as accurate or inaccurate. If
9181 ACCURATE_P is non-zero mark display of W as accurate. If
9182 ACCURATE_P is zero, arrange for W to be redisplayed the next time
9183 redisplay_internal is called. */
9186 mark_window_display_accurate_1 (w
, accurate_p
)
9190 if (BUFFERP (w
->buffer
))
9192 struct buffer
*b
= XBUFFER (w
->buffer
);
9195 = make_number (accurate_p
? BUF_MODIFF (b
) : 0);
9196 w
->last_overlay_modified
9197 = make_number (accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0);
9199 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
) ? Qt
: Qnil
;
9203 b
->clip_changed
= 0;
9204 b
->prevent_redisplay_optimizations_p
= 0;
9206 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
9207 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
9208 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
9209 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
9211 w
->current_matrix
->buffer
= b
;
9212 w
->current_matrix
->begv
= BUF_BEGV (b
);
9213 w
->current_matrix
->zv
= BUF_ZV (b
);
9215 w
->last_cursor
= w
->cursor
;
9216 w
->last_cursor_off_p
= w
->cursor_off_p
;
9218 if (w
== XWINDOW (selected_window
))
9219 w
->last_point
= make_number (BUF_PT (b
));
9221 w
->last_point
= make_number (XMARKER (w
->pointm
)->charpos
);
9227 w
->window_end_valid
= w
->buffer
;
9228 #if 0 /* This is incorrect with variable-height lines. */
9229 xassert (XINT (w
->window_end_vpos
)
9231 - (WINDOW_WANTS_MODELINE_P (w
) ? 1 : 0)));
9233 w
->update_mode_line
= Qnil
;
9238 /* Mark the display of windows in the window tree rooted at WINDOW as
9239 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
9240 windows as accurate. If ACCURATE_P is zero, arrange for windows to
9241 be redisplayed the next time redisplay_internal is called. */
9244 mark_window_display_accurate (window
, accurate_p
)
9250 for (; !NILP (window
); window
= w
->next
)
9252 w
= XWINDOW (window
);
9253 mark_window_display_accurate_1 (w
, accurate_p
);
9255 if (!NILP (w
->vchild
))
9256 mark_window_display_accurate (w
->vchild
, accurate_p
);
9257 if (!NILP (w
->hchild
))
9258 mark_window_display_accurate (w
->hchild
, accurate_p
);
9263 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
9264 last_arrow_string
= Voverlay_arrow_string
;
9268 /* Force a thorough redisplay the next time by setting
9269 last_arrow_position and last_arrow_string to t, which is
9270 unequal to any useful value of Voverlay_arrow_... */
9271 last_arrow_position
= Qt
;
9272 last_arrow_string
= Qt
;
9277 /* Return value in display table DP (Lisp_Char_Table *) for character
9278 C. Since a display table doesn't have any parent, we don't have to
9279 follow parent. Do not call this function directly but use the
9280 macro DISP_CHAR_VECTOR. */
9283 disp_char_vector (dp
, c
)
9284 struct Lisp_Char_Table
*dp
;
9290 if (SINGLE_BYTE_CHAR_P (c
))
9291 return (dp
->contents
[c
]);
9293 SPLIT_CHAR (c
, code
[0], code
[1], code
[2]);
9296 else if (code
[2] < 32)
9299 /* Here, the possible range of code[0] (== charset ID) is
9300 128..max_charset. Since the top level char table contains data
9301 for multibyte characters after 256th element, we must increment
9302 code[0] by 128 to get a correct index. */
9304 code
[3] = -1; /* anchor */
9306 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
9308 val
= dp
->contents
[code
[i
]];
9309 if (!SUB_CHAR_TABLE_P (val
))
9310 return (NILP (val
) ? dp
->defalt
: val
);
9313 /* Here, val is a sub char table. We return the default value of
9315 return (dp
->defalt
);
9320 /***********************************************************************
9322 ***********************************************************************/
9324 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
9327 redisplay_windows (window
)
9330 while (!NILP (window
))
9332 struct window
*w
= XWINDOW (window
);
9334 if (!NILP (w
->hchild
))
9335 redisplay_windows (w
->hchild
);
9336 else if (!NILP (w
->vchild
))
9337 redisplay_windows (w
->vchild
);
9340 displayed_buffer
= XBUFFER (w
->buffer
);
9341 /* Use list_of_error, not Qerror, so that
9342 we catch only errors and don't run the debugger. */
9343 internal_condition_case_1 (redisplay_window_0
, window
,
9345 redisplay_window_error
);
9353 redisplay_window_error ()
9355 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
9360 redisplay_window_0 (window
)
9363 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
9364 redisplay_window (window
, 0);
9369 redisplay_window_1 (window
)
9372 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
9373 redisplay_window (window
, 1);
9377 /* Set cursor position of W. PT is assumed to be displayed in ROW.
9378 DELTA is the number of bytes by which positions recorded in ROW
9379 differ from current buffer positions. */
9382 set_cursor_from_row (w
, row
, matrix
, delta
, delta_bytes
, dy
, dvpos
)
9384 struct glyph_row
*row
;
9385 struct glyph_matrix
*matrix
;
9386 int delta
, delta_bytes
, dy
, dvpos
;
9388 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
9389 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
9391 int pt_old
= PT
- delta
;
9393 /* Skip over glyphs not having an object at the start of the row.
9394 These are special glyphs like truncation marks on terminal
9396 if (row
->displays_text_p
)
9398 && INTEGERP (glyph
->object
)
9399 && glyph
->charpos
< 0)
9401 x
+= glyph
->pixel_width
;
9406 && !INTEGERP (glyph
->object
)
9407 && (!BUFFERP (glyph
->object
)
9408 || glyph
->charpos
< pt_old
))
9410 x
+= glyph
->pixel_width
;
9414 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
9416 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
9417 w
->cursor
.y
= row
->y
+ dy
;
9419 if (w
== XWINDOW (selected_window
))
9421 if (!row
->continued_p
9422 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
9425 this_line_buffer
= XBUFFER (w
->buffer
);
9427 CHARPOS (this_line_start_pos
)
9428 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
9429 BYTEPOS (this_line_start_pos
)
9430 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
9432 CHARPOS (this_line_end_pos
)
9433 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
9434 BYTEPOS (this_line_end_pos
)
9435 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
9437 this_line_y
= w
->cursor
.y
;
9438 this_line_pixel_height
= row
->height
;
9439 this_line_vpos
= w
->cursor
.vpos
;
9440 this_line_start_x
= row
->x
;
9443 CHARPOS (this_line_start_pos
) = 0;
9448 /* Run window scroll functions, if any, for WINDOW with new window
9449 start STARTP. Sets the window start of WINDOW to that position.
9451 We assume that the window's buffer is really current. */
9453 static INLINE
struct text_pos
9454 run_window_scroll_functions (window
, startp
)
9456 struct text_pos startp
;
9458 struct window
*w
= XWINDOW (window
);
9459 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
9461 if (current_buffer
!= XBUFFER (w
->buffer
))
9464 if (!NILP (Vwindow_scroll_functions
))
9466 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
9467 make_number (CHARPOS (startp
)));
9468 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
9469 /* In case the hook functions switch buffers. */
9470 if (current_buffer
!= XBUFFER (w
->buffer
))
9471 set_buffer_internal_1 (XBUFFER (w
->buffer
));
9478 /* Make sure the line containing the cursor is fully visible.
9479 A value of 1 means there is nothing to be done.
9480 (Either the line is fully visible, or it cannot be made so,
9482 A value of 0 means the caller should do scrolling
9483 as if point had gone off the screen. */
9486 make_cursor_line_fully_visible (w
)
9489 struct glyph_matrix
*matrix
;
9490 struct glyph_row
*row
;
9493 /* It's not always possible to find the cursor, e.g, when a window
9494 is full of overlay strings. Don't do anything in that case. */
9495 if (w
->cursor
.vpos
< 0)
9498 matrix
= w
->desired_matrix
;
9499 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
9501 /* If the cursor row is not partially visible, there's nothing to do. */
9502 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (row
))
9505 /* If the row the cursor is in is taller than the window's height,
9506 it's not clear what to do, so do nothing. */
9507 window_height
= window_box_height (w
);
9508 if (row
->height
>= window_height
)
9514 /* This code used to try to scroll the window just enough to make
9515 the line visible. It returned 0 to say that the caller should
9516 allocate larger glyph matrices. */
9518 if (MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
9520 int dy
= row
->height
- row
->visible_height
;
9523 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
9525 else /* MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row)) */
9527 int dy
= - (row
->height
- row
->visible_height
);
9530 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
9533 /* When we change the cursor y-position of the selected window,
9534 change this_line_y as well so that the display optimization for
9535 the cursor line of the selected window in redisplay_internal uses
9536 the correct y-position. */
9537 if (w
== XWINDOW (selected_window
))
9538 this_line_y
= w
->cursor
.y
;
9540 /* If vscrolling requires a larger glyph matrix, arrange for a fresh
9541 redisplay with larger matrices. */
9542 if (matrix
->nrows
< required_matrix_height (w
))
9544 fonts_changed_p
= 1;
9553 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
9554 non-zero means only WINDOW is redisplayed in redisplay_internal.
9555 TEMP_SCROLL_STEP has the same meaning as scroll_step, and is used
9556 in redisplay_window to bring a partially visible line into view in
9557 the case that only the cursor has moved.
9561 1 if scrolling succeeded
9563 0 if scrolling didn't find point.
9565 -1 if new fonts have been loaded so that we must interrupt
9566 redisplay, adjust glyph matrices, and try again. */
9572 SCROLLING_NEED_LARGER_MATRICES
9576 try_scrolling (window
, just_this_one_p
, scroll_conservatively
,
9577 scroll_step
, temp_scroll_step
)
9579 int just_this_one_p
;
9580 EMACS_INT scroll_conservatively
, scroll_step
;
9581 int temp_scroll_step
;
9583 struct window
*w
= XWINDOW (window
);
9584 struct frame
*f
= XFRAME (w
->frame
);
9585 struct text_pos scroll_margin_pos
;
9586 struct text_pos pos
;
9587 struct text_pos startp
;
9589 Lisp_Object window_end
;
9590 int this_scroll_margin
;
9594 int amount_to_scroll
= 0;
9595 Lisp_Object aggressive
;
9599 debug_method_add (w
, "try_scrolling");
9602 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
9604 /* Compute scroll margin height in pixels. We scroll when point is
9605 within this distance from the top or bottom of the window. */
9606 if (scroll_margin
> 0)
9608 this_scroll_margin
= min (scroll_margin
, XINT (w
->height
) / 4);
9609 this_scroll_margin
*= CANON_Y_UNIT (f
);
9612 this_scroll_margin
= 0;
9614 /* Compute how much we should try to scroll maximally to bring point
9616 if (scroll_step
|| scroll_conservatively
|| temp_scroll_step
)
9617 scroll_max
= max (scroll_step
,
9618 max (scroll_conservatively
, temp_scroll_step
));
9619 else if (NUMBERP (current_buffer
->scroll_down_aggressively
)
9620 || NUMBERP (current_buffer
->scroll_up_aggressively
))
9621 /* We're trying to scroll because of aggressive scrolling
9622 but no scroll_step is set. Choose an arbitrary one. Maybe
9623 there should be a variable for this. */
9627 scroll_max
*= CANON_Y_UNIT (f
);
9629 /* Decide whether we have to scroll down. Start at the window end
9630 and move this_scroll_margin up to find the position of the scroll
9632 window_end
= Fwindow_end (window
, Qt
);
9633 CHARPOS (scroll_margin_pos
) = XINT (window_end
);
9634 BYTEPOS (scroll_margin_pos
) = CHAR_TO_BYTE (CHARPOS (scroll_margin_pos
));
9635 if (this_scroll_margin
)
9637 start_display (&it
, w
, scroll_margin_pos
);
9638 move_it_vertically (&it
, - this_scroll_margin
);
9639 scroll_margin_pos
= it
.current
.pos
;
9642 if (PT
>= CHARPOS (scroll_margin_pos
))
9647 /* Point is in the scroll margin at the bottom of the window, or
9648 below. Compute a new window start that makes point visible. */
9650 /* Compute the distance from the scroll margin to PT.
9651 Give up if the distance is greater than scroll_max. */
9652 start_display (&it
, w
, scroll_margin_pos
);
9654 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
9655 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
9657 /* To make point visible, we have to move the window start
9658 down so that the line the cursor is in is visible, which
9659 means we have to add in the height of the cursor line. */
9660 dy
= line_bottom_y (&it
) - y0
;
9662 if (dy
> scroll_max
)
9663 return SCROLLING_FAILED
;
9665 /* Move the window start down. If scrolling conservatively,
9666 move it just enough down to make point visible. If
9667 scroll_step is set, move it down by scroll_step. */
9668 start_display (&it
, w
, startp
);
9670 if (scroll_conservatively
)
9672 = max (max (dy
, CANON_Y_UNIT (f
)),
9673 CANON_Y_UNIT (f
) * max (scroll_step
, temp_scroll_step
));
9674 else if (scroll_step
|| temp_scroll_step
)
9675 amount_to_scroll
= scroll_max
;
9678 aggressive
= current_buffer
->scroll_up_aggressively
;
9679 height
= (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
)
9680 - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
9681 if (NUMBERP (aggressive
))
9682 amount_to_scroll
= XFLOATINT (aggressive
) * height
;
9685 if (amount_to_scroll
<= 0)
9686 return SCROLLING_FAILED
;
9688 move_it_vertically (&it
, amount_to_scroll
);
9689 startp
= it
.current
.pos
;
9693 /* See if point is inside the scroll margin at the top of the
9695 scroll_margin_pos
= startp
;
9696 if (this_scroll_margin
)
9698 start_display (&it
, w
, startp
);
9699 move_it_vertically (&it
, this_scroll_margin
);
9700 scroll_margin_pos
= it
.current
.pos
;
9703 if (PT
< CHARPOS (scroll_margin_pos
))
9705 /* Point is in the scroll margin at the top of the window or
9706 above what is displayed in the window. */
9709 /* Compute the vertical distance from PT to the scroll
9710 margin position. Give up if distance is greater than
9712 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
9713 start_display (&it
, w
, pos
);
9715 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
9716 it
.last_visible_y
, -1,
9717 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
9718 dy
= it
.current_y
- y0
;
9719 if (dy
> scroll_max
)
9720 return SCROLLING_FAILED
;
9722 /* Compute new window start. */
9723 start_display (&it
, w
, startp
);
9725 if (scroll_conservatively
)
9727 max (dy
, CANON_Y_UNIT (f
) * max (scroll_step
, temp_scroll_step
));
9728 else if (scroll_step
|| temp_scroll_step
)
9729 amount_to_scroll
= scroll_max
;
9732 aggressive
= current_buffer
->scroll_down_aggressively
;
9733 height
= (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
)
9734 - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
9735 if (NUMBERP (aggressive
))
9736 amount_to_scroll
= XFLOATINT (aggressive
) * height
;
9739 if (amount_to_scroll
<= 0)
9740 return SCROLLING_FAILED
;
9742 move_it_vertically (&it
, - amount_to_scroll
);
9743 startp
= it
.current
.pos
;
9747 /* Run window scroll functions. */
9748 startp
= run_window_scroll_functions (window
, startp
);
9750 /* Display the window. Give up if new fonts are loaded, or if point
9752 if (!try_window (window
, startp
))
9753 rc
= SCROLLING_NEED_LARGER_MATRICES
;
9754 else if (w
->cursor
.vpos
< 0)
9756 clear_glyph_matrix (w
->desired_matrix
);
9757 rc
= SCROLLING_FAILED
;
9761 /* Maybe forget recorded base line for line number display. */
9762 if (!just_this_one_p
9763 || current_buffer
->clip_changed
9764 || BEG_UNCHANGED
< CHARPOS (startp
))
9765 w
->base_line_number
= Qnil
;
9767 /* If cursor ends up on a partially visible line,
9768 treat that as being off the bottom of the screen. */
9769 if (! make_cursor_line_fully_visible (w
))
9771 rc
= SCROLLING_SUCCESS
;
9778 /* Compute a suitable window start for window W if display of W starts
9779 on a continuation line. Value is non-zero if a new window start
9782 The new window start will be computed, based on W's width, starting
9783 from the start of the continued line. It is the start of the
9784 screen line with the minimum distance from the old start W->start. */
9787 compute_window_start_on_continuation_line (w
)
9790 struct text_pos pos
, start_pos
;
9791 int window_start_changed_p
= 0;
9793 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
9795 /* If window start is on a continuation line... Window start may be
9796 < BEGV in case there's invisible text at the start of the
9797 buffer (M-x rmail, for example). */
9798 if (CHARPOS (start_pos
) > BEGV
9799 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
9802 struct glyph_row
*row
;
9804 /* Handle the case that the window start is out of range. */
9805 if (CHARPOS (start_pos
) < BEGV
)
9806 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
9807 else if (CHARPOS (start_pos
) > ZV
)
9808 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
9810 /* Find the start of the continued line. This should be fast
9811 because scan_buffer is fast (newline cache). */
9812 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
9813 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
9814 row
, DEFAULT_FACE_ID
);
9815 reseat_at_previous_visible_line_start (&it
);
9817 /* If the line start is "too far" away from the window start,
9818 say it takes too much time to compute a new window start. */
9819 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
9820 < XFASTINT (w
->height
) * XFASTINT (w
->width
))
9822 int min_distance
, distance
;
9824 /* Move forward by display lines to find the new window
9825 start. If window width was enlarged, the new start can
9826 be expected to be > the old start. If window width was
9827 decreased, the new window start will be < the old start.
9828 So, we're looking for the display line start with the
9829 minimum distance from the old window start. */
9830 pos
= it
.current
.pos
;
9831 min_distance
= INFINITY
;
9832 while ((distance
= abs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
9833 distance
< min_distance
)
9835 min_distance
= distance
;
9836 pos
= it
.current
.pos
;
9837 move_it_by_lines (&it
, 1, 0);
9840 /* Set the window start there. */
9841 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
9842 window_start_changed_p
= 1;
9846 return window_start_changed_p
;
9850 /* Try cursor movement in case text has not changed in window WINDOW,
9851 with window start STARTP. Value is
9853 CURSOR_MOVEMENT_SUCCESS if successful
9855 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
9857 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
9858 display. *SCROLL_STEP is set to 1, under certain circumstances, if
9859 we want to scroll as if scroll-step were set to 1. See the code.
9861 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
9862 which case we have to abort this redisplay, and adjust matrices
9867 CURSOR_MOVEMENT_SUCCESS
,
9868 CURSOR_MOVEMENT_CANNOT_BE_USED
,
9869 CURSOR_MOVEMENT_MUST_SCROLL
,
9870 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
9874 try_cursor_movement (window
, startp
, scroll_step
)
9876 struct text_pos startp
;
9879 struct window
*w
= XWINDOW (window
);
9880 struct frame
*f
= XFRAME (w
->frame
);
9881 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
9884 if (inhibit_try_cursor_movement
)
9888 /* Handle case where text has not changed, only point, and it has
9889 not moved off the frame. */
9890 if (/* Point may be in this window. */
9891 PT
>= CHARPOS (startp
)
9892 /* Selective display hasn't changed. */
9893 && !current_buffer
->clip_changed
9894 /* Function force-mode-line-update is used to force a thorough
9895 redisplay. It sets either windows_or_buffers_changed or
9896 update_mode_lines. So don't take a shortcut here for these
9898 && !update_mode_lines
9899 && !windows_or_buffers_changed
9900 && !cursor_type_changed
9901 /* Can't use this case if highlighting a region. When a
9902 region exists, cursor movement has to do more than just
9904 && !(!NILP (Vtransient_mark_mode
)
9905 && !NILP (current_buffer
->mark_active
))
9906 && NILP (w
->region_showing
)
9907 && NILP (Vshow_trailing_whitespace
)
9908 /* Right after splitting windows, last_point may be nil. */
9909 && INTEGERP (w
->last_point
)
9910 /* This code is not used for mini-buffer for the sake of the case
9911 of redisplaying to replace an echo area message; since in
9912 that case the mini-buffer contents per se are usually
9913 unchanged. This code is of no real use in the mini-buffer
9914 since the handling of this_line_start_pos, etc., in redisplay
9915 handles the same cases. */
9916 && !EQ (window
, minibuf_window
)
9917 /* When splitting windows or for new windows, it happens that
9918 redisplay is called with a nil window_end_vpos or one being
9919 larger than the window. This should really be fixed in
9920 window.c. I don't have this on my list, now, so we do
9921 approximately the same as the old redisplay code. --gerd. */
9922 && INTEGERP (w
->window_end_vpos
)
9923 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
9924 && (FRAME_WINDOW_P (f
)
9925 || !MARKERP (Voverlay_arrow_position
)
9926 || current_buffer
!= XMARKER (Voverlay_arrow_position
)->buffer
))
9928 int this_scroll_margin
;
9929 struct glyph_row
*row
= NULL
;
9932 debug_method_add (w
, "cursor movement");
9935 /* Scroll if point within this distance from the top or bottom
9936 of the window. This is a pixel value. */
9937 this_scroll_margin
= max (0, scroll_margin
);
9938 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->height
) / 4);
9939 this_scroll_margin
*= CANON_Y_UNIT (f
);
9941 /* Start with the row the cursor was displayed during the last
9942 not paused redisplay. Give up if that row is not valid. */
9943 if (w
->last_cursor
.vpos
< 0
9944 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
9945 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
9948 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
9949 if (row
->mode_line_p
)
9951 if (!row
->enabled_p
)
9952 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
9955 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
9958 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
9960 if (PT
> XFASTINT (w
->last_point
))
9962 /* Point has moved forward. */
9963 while (MATRIX_ROW_END_CHARPOS (row
) < PT
9964 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
9966 xassert (row
->enabled_p
);
9970 /* The end position of a row equals the start position
9971 of the next row. If PT is there, we would rather
9972 display it in the next line. */
9973 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
9974 && MATRIX_ROW_END_CHARPOS (row
) == PT
9975 && !cursor_row_p (w
, row
))
9978 /* If within the scroll margin, scroll. Note that
9979 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
9980 the next line would be drawn, and that
9981 this_scroll_margin can be zero. */
9982 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
9983 || PT
> MATRIX_ROW_END_CHARPOS (row
)
9984 /* Line is completely visible last line in window
9985 and PT is to be set in the next line. */
9986 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
9987 && PT
== MATRIX_ROW_END_CHARPOS (row
)
9988 && !row
->ends_at_zv_p
9989 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
9992 else if (PT
< XFASTINT (w
->last_point
))
9994 /* Cursor has to be moved backward. Note that PT >=
9995 CHARPOS (startp) because of the outer
9997 while (!row
->mode_line_p
9998 && (MATRIX_ROW_START_CHARPOS (row
) > PT
9999 || (MATRIX_ROW_START_CHARPOS (row
) == PT
10000 && MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)))
10001 && (row
->y
> this_scroll_margin
10002 || CHARPOS (startp
) == BEGV
))
10004 xassert (row
->enabled_p
);
10008 /* Consider the following case: Window starts at BEGV,
10009 there is invisible, intangible text at BEGV, so that
10010 display starts at some point START > BEGV. It can
10011 happen that we are called with PT somewhere between
10012 BEGV and START. Try to handle that case. */
10013 if (row
< w
->current_matrix
->rows
10014 || row
->mode_line_p
)
10016 row
= w
->current_matrix
->rows
;
10017 if (row
->mode_line_p
)
10021 /* Due to newlines in overlay strings, we may have to
10022 skip forward over overlay strings. */
10023 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
10024 && MATRIX_ROW_END_CHARPOS (row
) == PT
10025 && !cursor_row_p (w
, row
))
10028 /* If within the scroll margin, scroll. */
10029 if (row
->y
< this_scroll_margin
10030 && CHARPOS (startp
) != BEGV
)
10034 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
10035 || PT
> MATRIX_ROW_END_CHARPOS (row
))
10037 /* if PT is not in the glyph row, give up. */
10038 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
10040 else if (MATRIX_ROW_PARTIALLY_VISIBLE_P (row
))
10042 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
10043 && !row
->ends_at_zv_p
10044 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
10045 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
10046 else if (row
->height
> window_box_height (w
))
10048 /* If we end up in a partially visible line, let's
10049 make it fully visible, except when it's taller
10050 than the window, in which case we can't do much
10053 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
10057 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10058 try_window (window
, startp
);
10059 if (!make_cursor_line_fully_visible (w
))
10060 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
10062 rc
= CURSOR_MOVEMENT_SUCCESS
;
10066 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
10069 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10070 rc
= CURSOR_MOVEMENT_SUCCESS
;
10079 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
10080 selected_window is redisplayed. */
10083 redisplay_window (window
, just_this_one_p
)
10084 Lisp_Object window
;
10085 int just_this_one_p
;
10087 struct window
*w
= XWINDOW (window
);
10088 struct frame
*f
= XFRAME (w
->frame
);
10089 struct buffer
*buffer
= XBUFFER (w
->buffer
);
10090 struct buffer
*old
= current_buffer
;
10091 struct text_pos lpoint
, opoint
, startp
;
10092 int update_mode_line
;
10095 /* Record it now because it's overwritten. */
10096 int current_matrix_up_to_date_p
= 0;
10097 /* This is less strict than current_matrix_up_to_date_p.
10098 It indictes that the buffer contents and narrowing are unchanged. */
10099 int buffer_unchanged_p
= 0;
10100 int temp_scroll_step
= 0;
10101 int count
= SPECPDL_INDEX ();
10103 int centering_position
;
10105 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
10108 /* W must be a leaf window here. */
10109 xassert (!NILP (w
->buffer
));
10111 *w
->desired_matrix
->method
= 0;
10114 specbind (Qinhibit_point_motion_hooks
, Qt
);
10116 reconsider_clip_changes (w
, buffer
);
10118 /* Has the mode line to be updated? */
10119 update_mode_line
= (!NILP (w
->update_mode_line
)
10120 || update_mode_lines
10121 || buffer
->clip_changed
10122 || buffer
->prevent_redisplay_optimizations_p
);
10124 if (MINI_WINDOW_P (w
))
10126 if (w
== XWINDOW (echo_area_window
)
10127 && !NILP (echo_area_buffer
[0]))
10129 if (update_mode_line
)
10130 /* We may have to update a tty frame's menu bar or a
10131 tool-bar. Example `M-x C-h C-h C-g'. */
10132 goto finish_menu_bars
;
10134 /* We've already displayed the echo area glyphs in this window. */
10135 goto finish_scroll_bars
;
10137 else if (w
!= XWINDOW (minibuf_window
))
10139 /* W is a mini-buffer window, but it's not the currently
10140 active one, so clear it. */
10141 int yb
= window_text_bottom_y (w
);
10142 struct glyph_row
*row
;
10145 for (y
= 0, row
= w
->desired_matrix
->rows
;
10147 y
+= row
->height
, ++row
)
10148 blank_row (w
, row
, y
);
10149 goto finish_scroll_bars
;
10152 clear_glyph_matrix (w
->desired_matrix
);
10155 /* Otherwise set up data on this window; select its buffer and point
10157 /* Really select the buffer, for the sake of buffer-local
10159 set_buffer_internal_1 (XBUFFER (w
->buffer
));
10160 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
10162 current_matrix_up_to_date_p
10163 = (!NILP (w
->window_end_valid
)
10164 && !current_buffer
->clip_changed
10165 && !current_buffer
->prevent_redisplay_optimizations_p
10166 && XFASTINT (w
->last_modified
) >= MODIFF
10167 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
10170 = (!NILP (w
->window_end_valid
)
10171 && !current_buffer
->clip_changed
10172 && XFASTINT (w
->last_modified
) >= MODIFF
10173 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
10175 /* When windows_or_buffers_changed is non-zero, we can't rely on
10176 the window end being valid, so set it to nil there. */
10177 if (windows_or_buffers_changed
)
10179 /* If window starts on a continuation line, maybe adjust the
10180 window start in case the window's width changed. */
10181 if (XMARKER (w
->start
)->buffer
== current_buffer
)
10182 compute_window_start_on_continuation_line (w
);
10184 w
->window_end_valid
= Qnil
;
10187 /* Some sanity checks. */
10188 CHECK_WINDOW_END (w
);
10189 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
10191 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
10194 /* If %c is in mode line, update it if needed. */
10195 if (!NILP (w
->column_number_displayed
)
10196 /* This alternative quickly identifies a common case
10197 where no change is needed. */
10198 && !(PT
== XFASTINT (w
->last_point
)
10199 && XFASTINT (w
->last_modified
) >= MODIFF
10200 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
10201 && (XFASTINT (w
->column_number_displayed
)
10202 != (int) current_column ())) /* iftc */
10203 update_mode_line
= 1;
10205 /* Count number of windows showing the selected buffer. An indirect
10206 buffer counts as its base buffer. */
10207 if (!just_this_one_p
)
10209 struct buffer
*current_base
, *window_base
;
10210 current_base
= current_buffer
;
10211 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
10212 if (current_base
->base_buffer
)
10213 current_base
= current_base
->base_buffer
;
10214 if (window_base
->base_buffer
)
10215 window_base
= window_base
->base_buffer
;
10216 if (current_base
== window_base
)
10220 /* Point refers normally to the selected window. For any other
10221 window, set up appropriate value. */
10222 if (!EQ (window
, selected_window
))
10224 int new_pt
= XMARKER (w
->pointm
)->charpos
;
10225 int new_pt_byte
= marker_byte_position (w
->pointm
);
10229 new_pt_byte
= BEGV_BYTE
;
10230 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
10232 else if (new_pt
> (ZV
- 1))
10235 new_pt_byte
= ZV_BYTE
;
10236 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
10239 /* We don't use SET_PT so that the point-motion hooks don't run. */
10240 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
10243 /* If any of the character widths specified in the display table
10244 have changed, invalidate the width run cache. It's true that
10245 this may be a bit late to catch such changes, but the rest of
10246 redisplay goes (non-fatally) haywire when the display table is
10247 changed, so why should we worry about doing any better? */
10248 if (current_buffer
->width_run_cache
)
10250 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
10252 if (! disptab_matches_widthtab (disptab
,
10253 XVECTOR (current_buffer
->width_table
)))
10255 invalidate_region_cache (current_buffer
,
10256 current_buffer
->width_run_cache
,
10258 recompute_width_table (current_buffer
, disptab
);
10262 /* If window-start is screwed up, choose a new one. */
10263 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
10266 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
10268 /* If someone specified a new starting point but did not insist,
10269 check whether it can be used. */
10270 if (!NILP (w
->optional_new_start
)
10271 && CHARPOS (startp
) >= BEGV
10272 && CHARPOS (startp
) <= ZV
)
10274 w
->optional_new_start
= Qnil
;
10275 start_display (&it
, w
, startp
);
10276 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
10277 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
10278 if (IT_CHARPOS (it
) == PT
)
10279 w
->force_start
= Qt
;
10282 /* Handle case where place to start displaying has been specified,
10283 unless the specified location is outside the accessible range. */
10284 if (!NILP (w
->force_start
)
10285 || w
->frozen_window_start_p
)
10287 w
->force_start
= Qnil
;
10289 w
->window_end_valid
= Qnil
;
10291 /* Forget any recorded base line for line number display. */
10292 if (!buffer_unchanged_p
)
10293 w
->base_line_number
= Qnil
;
10295 /* Redisplay the mode line. Select the buffer properly for that.
10296 Also, run the hook window-scroll-functions
10297 because we have scrolled. */
10298 /* Note, we do this after clearing force_start because
10299 if there's an error, it is better to forget about force_start
10300 than to get into an infinite loop calling the hook functions
10301 and having them get more errors. */
10302 if (!update_mode_line
10303 || ! NILP (Vwindow_scroll_functions
))
10305 update_mode_line
= 1;
10306 w
->update_mode_line
= Qt
;
10307 startp
= run_window_scroll_functions (window
, startp
);
10310 w
->last_modified
= make_number (0);
10311 w
->last_overlay_modified
= make_number (0);
10312 if (CHARPOS (startp
) < BEGV
)
10313 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
10314 else if (CHARPOS (startp
) > ZV
)
10315 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
10317 /* Redisplay, then check if cursor has been set during the
10318 redisplay. Give up if new fonts were loaded. */
10319 if (!try_window (window
, startp
))
10321 w
->force_start
= Qt
;
10322 clear_glyph_matrix (w
->desired_matrix
);
10323 goto finish_scroll_bars
;
10326 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
10328 /* If point does not appear, try to move point so it does
10329 appear. The desired matrix has been built above, so we
10330 can use it here. */
10332 struct glyph_row
*row
;
10334 window_height
= window_box_height (w
) / 2;
10335 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
10336 while (MATRIX_ROW_BOTTOM_Y (row
) < window_height
)
10339 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
10340 MATRIX_ROW_START_BYTEPOS (row
));
10342 if (w
!= XWINDOW (selected_window
))
10343 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
10344 else if (current_buffer
== old
)
10345 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
10347 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
10349 /* If we are highlighting the region, then we just changed
10350 the region, so redisplay to show it. */
10351 if (!NILP (Vtransient_mark_mode
)
10352 && !NILP (current_buffer
->mark_active
))
10354 clear_glyph_matrix (w
->desired_matrix
);
10355 if (!try_window (window
, startp
))
10356 goto need_larger_matrices
;
10360 if (!make_cursor_line_fully_visible (w
))
10361 goto try_to_scroll
;
10363 debug_method_add (w
, "forced window start");
10368 /* Handle case where text has not changed, only point, and it has
10369 not moved off the frame, and we are not retrying after hscroll.
10370 (current_matrix_up_to_date_p is nonzero when retrying.) */
10371 if (current_matrix_up_to_date_p
10372 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
10373 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
10377 case CURSOR_MOVEMENT_SUCCESS
:
10380 case CURSOR_MOVEMENT_NEED_LARGER_MATRICES
:
10381 goto need_larger_matrices
;
10383 case CURSOR_MOVEMENT_MUST_SCROLL
:
10384 goto try_to_scroll
;
10390 /* If current starting point was originally the beginning of a line
10391 but no longer is, find a new starting point. */
10392 else if (!NILP (w
->start_at_line_beg
)
10393 && !(CHARPOS (startp
) <= BEGV
10394 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
10397 debug_method_add (w
, "recenter 1");
10402 /* Try scrolling with try_window_id. Value is > 0 if update has
10403 been done, it is -1 if we know that the same window start will
10404 not work. It is 0 if unsuccessful for some other reason. */
10405 else if ((tem
= try_window_id (w
)) != 0)
10408 debug_method_add (w
, "try_window_id %d", tem
);
10411 if (fonts_changed_p
)
10412 goto need_larger_matrices
;
10416 /* Otherwise try_window_id has returned -1 which means that we
10417 don't want the alternative below this comment to execute. */
10419 else if (CHARPOS (startp
) >= BEGV
10420 && CHARPOS (startp
) <= ZV
10421 && PT
>= CHARPOS (startp
)
10422 && (CHARPOS (startp
) < ZV
10423 /* Avoid starting at end of buffer. */
10424 || CHARPOS (startp
) == BEGV
10425 || (XFASTINT (w
->last_modified
) >= MODIFF
10426 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
10429 debug_method_add (w
, "same window start");
10432 /* Try to redisplay starting at same place as before.
10433 If point has not moved off frame, accept the results. */
10434 if (!current_matrix_up_to_date_p
10435 /* Don't use try_window_reusing_current_matrix in this case
10436 because a window scroll function can have changed the
10438 || !NILP (Vwindow_scroll_functions
)
10439 || MINI_WINDOW_P (w
)
10440 || !try_window_reusing_current_matrix (w
))
10442 IF_DEBUG (debug_method_add (w
, "1"));
10443 try_window (window
, startp
);
10446 if (fonts_changed_p
)
10447 goto need_larger_matrices
;
10449 if (w
->cursor
.vpos
>= 0)
10451 if (!just_this_one_p
10452 || current_buffer
->clip_changed
10453 || BEG_UNCHANGED
< CHARPOS (startp
))
10454 /* Forget any recorded base line for line number display. */
10455 w
->base_line_number
= Qnil
;
10457 if (!make_cursor_line_fully_visible (w
))
10458 /* Drop through and scroll. */
10463 clear_glyph_matrix (w
->desired_matrix
);
10468 w
->last_modified
= make_number (0);
10469 w
->last_overlay_modified
= make_number (0);
10471 /* Redisplay the mode line. Select the buffer properly for that. */
10472 if (!update_mode_line
)
10474 update_mode_line
= 1;
10475 w
->update_mode_line
= Qt
;
10478 /* Try to scroll by specified few lines. */
10479 if ((scroll_conservatively
10481 || temp_scroll_step
10482 || NUMBERP (current_buffer
->scroll_up_aggressively
)
10483 || NUMBERP (current_buffer
->scroll_down_aggressively
))
10484 && !current_buffer
->clip_changed
10485 && CHARPOS (startp
) >= BEGV
10486 && CHARPOS (startp
) <= ZV
)
10488 /* The function returns -1 if new fonts were loaded, 1 if
10489 successful, 0 if not successful. */
10490 int rc
= try_scrolling (window
, just_this_one_p
,
10491 scroll_conservatively
,
10496 case SCROLLING_SUCCESS
:
10499 case SCROLLING_NEED_LARGER_MATRICES
:
10500 goto need_larger_matrices
;
10502 case SCROLLING_FAILED
:
10510 /* Finally, just choose place to start which centers point */
10513 centering_position
= window_box_height (w
) / 2;
10516 /* Jump here with centering_position already set to 0. */
10519 debug_method_add (w
, "recenter");
10522 /* w->vscroll = 0; */
10524 /* Forget any previously recorded base line for line number display. */
10525 if (!buffer_unchanged_p
)
10526 w
->base_line_number
= Qnil
;
10528 /* Move backward half the height of the window. */
10529 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
10530 it
.current_y
= it
.last_visible_y
;
10531 move_it_vertically_backward (&it
, centering_position
);
10532 xassert (IT_CHARPOS (it
) >= BEGV
);
10534 /* The function move_it_vertically_backward may move over more
10535 than the specified y-distance. If it->w is small, e.g. a
10536 mini-buffer window, we may end up in front of the window's
10537 display area. Start displaying at the start of the line
10538 containing PT in this case. */
10539 if (it
.current_y
<= 0)
10541 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
10542 move_it_vertically (&it
, 0);
10543 xassert (IT_CHARPOS (it
) <= PT
);
10547 it
.current_x
= it
.hpos
= 0;
10549 /* Set startp here explicitly in case that helps avoid an infinite loop
10550 in case the window-scroll-functions functions get errors. */
10551 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
10553 /* Run scroll hooks. */
10554 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
10556 /* Redisplay the window. */
10557 if (!current_matrix_up_to_date_p
10558 || windows_or_buffers_changed
10559 || cursor_type_changed
10560 /* Don't use try_window_reusing_current_matrix in this case
10561 because it can have changed the buffer. */
10562 || !NILP (Vwindow_scroll_functions
)
10563 || !just_this_one_p
10564 || MINI_WINDOW_P (w
)
10565 || !try_window_reusing_current_matrix (w
))
10566 try_window (window
, startp
);
10568 /* If new fonts have been loaded (due to fontsets), give up. We
10569 have to start a new redisplay since we need to re-adjust glyph
10571 if (fonts_changed_p
)
10572 goto need_larger_matrices
;
10574 /* If cursor did not appear assume that the middle of the window is
10575 in the first line of the window. Do it again with the next line.
10576 (Imagine a window of height 100, displaying two lines of height
10577 60. Moving back 50 from it->last_visible_y will end in the first
10579 if (w
->cursor
.vpos
< 0)
10581 if (!NILP (w
->window_end_valid
)
10582 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
10584 clear_glyph_matrix (w
->desired_matrix
);
10585 move_it_by_lines (&it
, 1, 0);
10586 try_window (window
, it
.current
.pos
);
10588 else if (PT
< IT_CHARPOS (it
))
10590 clear_glyph_matrix (w
->desired_matrix
);
10591 move_it_by_lines (&it
, -1, 0);
10592 try_window (window
, it
.current
.pos
);
10596 /* Not much we can do about it. */
10600 /* Consider the following case: Window starts at BEGV, there is
10601 invisible, intangible text at BEGV, so that display starts at
10602 some point START > BEGV. It can happen that we are called with
10603 PT somewhere between BEGV and START. Try to handle that case. */
10604 if (w
->cursor
.vpos
< 0)
10606 struct glyph_row
*row
= w
->current_matrix
->rows
;
10607 if (row
->mode_line_p
)
10609 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10612 if (!make_cursor_line_fully_visible (w
))
10614 /* If centering point failed to make the whole line visible,
10615 put point at the top instead. That has to make the whole line
10616 visible, if it can be done. */
10617 centering_position
= 0;
10623 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
10624 w
->start_at_line_beg
= ((CHARPOS (startp
) == BEGV
10625 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n')
10628 /* Display the mode line, if we must. */
10629 if ((update_mode_line
10630 /* If window not full width, must redo its mode line
10631 if (a) the window to its side is being redone and
10632 (b) we do a frame-based redisplay. This is a consequence
10633 of how inverted lines are drawn in frame-based redisplay. */
10634 || (!just_this_one_p
10635 && !FRAME_WINDOW_P (f
)
10636 && !WINDOW_FULL_WIDTH_P (w
))
10637 /* Line number to display. */
10638 || INTEGERP (w
->base_line_pos
)
10639 /* Column number is displayed and different from the one displayed. */
10640 || (!NILP (w
->column_number_displayed
)
10641 && (XFASTINT (w
->column_number_displayed
)
10642 != (int) current_column ()))) /* iftc */
10643 /* This means that the window has a mode line. */
10644 && (WINDOW_WANTS_MODELINE_P (w
)
10645 || WINDOW_WANTS_HEADER_LINE_P (w
)))
10647 display_mode_lines (w
);
10649 /* If mode line height has changed, arrange for a thorough
10650 immediate redisplay using the correct mode line height. */
10651 if (WINDOW_WANTS_MODELINE_P (w
)
10652 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
10654 fonts_changed_p
= 1;
10655 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
10656 = DESIRED_MODE_LINE_HEIGHT (w
);
10659 /* If top line height has changed, arrange for a thorough
10660 immediate redisplay using the correct mode line height. */
10661 if (WINDOW_WANTS_HEADER_LINE_P (w
)
10662 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
10664 fonts_changed_p
= 1;
10665 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
10666 = DESIRED_HEADER_LINE_HEIGHT (w
);
10669 if (fonts_changed_p
)
10670 goto need_larger_matrices
;
10673 if (!line_number_displayed
10674 && !BUFFERP (w
->base_line_pos
))
10676 w
->base_line_pos
= Qnil
;
10677 w
->base_line_number
= Qnil
;
10682 /* When we reach a frame's selected window, redo the frame's menu bar. */
10683 if (update_mode_line
10684 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
10686 int redisplay_menu_p
= 0;
10688 if (FRAME_WINDOW_P (f
))
10690 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
10691 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
10693 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
10697 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
10699 if (redisplay_menu_p
)
10700 display_menu_bar (w
);
10702 #ifdef HAVE_WINDOW_SYSTEM
10703 if (WINDOWP (f
->tool_bar_window
)
10704 && (FRAME_TOOL_BAR_LINES (f
) > 0
10705 || auto_resize_tool_bars_p
))
10706 redisplay_tool_bar (f
);
10710 need_larger_matrices
:
10712 finish_scroll_bars
:
10714 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
10716 int start
, end
, whole
;
10718 /* Calculate the start and end positions for the current window.
10719 At some point, it would be nice to choose between scrollbars
10720 which reflect the whole buffer size, with special markers
10721 indicating narrowing, and scrollbars which reflect only the
10724 Note that mini-buffers sometimes aren't displaying any text. */
10725 if (!MINI_WINDOW_P (w
)
10726 || (w
== XWINDOW (minibuf_window
)
10727 && NILP (echo_area_buffer
[0])))
10730 start
= marker_position (w
->start
) - BEGV
;
10731 /* I don't think this is guaranteed to be right. For the
10732 moment, we'll pretend it is. */
10733 end
= (Z
- XFASTINT (w
->window_end_pos
)) - BEGV
;
10737 if (whole
< (end
- start
))
10738 whole
= end
- start
;
10741 start
= end
= whole
= 0;
10743 /* Indicate what this scroll bar ought to be displaying now. */
10744 set_vertical_scroll_bar_hook (w
, end
- start
, whole
, start
);
10746 /* Note that we actually used the scroll bar attached to this
10747 window, so it shouldn't be deleted at the end of redisplay. */
10748 redeem_scroll_bar_hook (w
);
10751 /* Restore current_buffer and value of point in it. */
10752 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
10753 set_buffer_internal_1 (old
);
10754 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
10756 unbind_to (count
, Qnil
);
10760 /* Build the complete desired matrix of WINDOW with a window start
10761 buffer position POS. Value is non-zero if successful. It is zero
10762 if fonts were loaded during redisplay which makes re-adjusting
10763 glyph matrices necessary. */
10766 try_window (window
, pos
)
10767 Lisp_Object window
;
10768 struct text_pos pos
;
10770 struct window
*w
= XWINDOW (window
);
10772 struct glyph_row
*last_text_row
= NULL
;
10774 /* Make POS the new window start. */
10775 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
10777 /* Mark cursor position as unknown. No overlay arrow seen. */
10778 w
->cursor
.vpos
= -1;
10779 overlay_arrow_seen
= 0;
10781 /* Initialize iterator and info to start at POS. */
10782 start_display (&it
, w
, pos
);
10784 /* Display all lines of W. */
10785 while (it
.current_y
< it
.last_visible_y
)
10787 if (display_line (&it
))
10788 last_text_row
= it
.glyph_row
- 1;
10789 if (fonts_changed_p
)
10793 /* If bottom moved off end of frame, change mode line percentage. */
10794 if (XFASTINT (w
->window_end_pos
) <= 0
10795 && Z
!= IT_CHARPOS (it
))
10796 w
->update_mode_line
= Qt
;
10798 /* Set window_end_pos to the offset of the last character displayed
10799 on the window from the end of current_buffer. Set
10800 window_end_vpos to its row number. */
10803 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
10804 w
->window_end_bytepos
10805 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
10807 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
10809 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
10810 xassert (MATRIX_ROW (w
->desired_matrix
, XFASTINT (w
->window_end_vpos
))
10811 ->displays_text_p
);
10815 w
->window_end_bytepos
= 0;
10816 w
->window_end_pos
= w
->window_end_vpos
= make_number (0);
10819 /* But that is not valid info until redisplay finishes. */
10820 w
->window_end_valid
= Qnil
;
10826 /************************************************************************
10827 Window redisplay reusing current matrix when buffer has not changed
10828 ************************************************************************/
10830 /* Try redisplay of window W showing an unchanged buffer with a
10831 different window start than the last time it was displayed by
10832 reusing its current matrix. Value is non-zero if successful.
10833 W->start is the new window start. */
10836 try_window_reusing_current_matrix (w
)
10839 struct frame
*f
= XFRAME (w
->frame
);
10840 struct glyph_row
*row
, *bottom_row
;
10843 struct text_pos start
, new_start
;
10844 int nrows_scrolled
, i
;
10845 struct glyph_row
*last_text_row
;
10846 struct glyph_row
*last_reused_text_row
;
10847 struct glyph_row
*start_row
;
10848 int start_vpos
, min_y
, max_y
;
10851 if (inhibit_try_window_reusing
)
10855 if (/* This function doesn't handle terminal frames. */
10856 !FRAME_WINDOW_P (f
)
10857 /* Don't try to reuse the display if windows have been split
10859 || windows_or_buffers_changed
10860 || cursor_type_changed
)
10863 /* Can't do this if region may have changed. */
10864 if ((!NILP (Vtransient_mark_mode
)
10865 && !NILP (current_buffer
->mark_active
))
10866 || !NILP (w
->region_showing
)
10867 || !NILP (Vshow_trailing_whitespace
))
10870 /* If top-line visibility has changed, give up. */
10871 if (WINDOW_WANTS_HEADER_LINE_P (w
)
10872 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
10875 /* Give up if old or new display is scrolled vertically. We could
10876 make this function handle this, but right now it doesn't. */
10877 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10878 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (start_row
))
10881 /* The variable new_start now holds the new window start. The old
10882 start `start' can be determined from the current matrix. */
10883 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
10884 start
= start_row
->start
.pos
;
10885 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
10887 /* Clear the desired matrix for the display below. */
10888 clear_glyph_matrix (w
->desired_matrix
);
10890 if (CHARPOS (new_start
) <= CHARPOS (start
))
10894 /* Don't use this method if the display starts with an ellipsis
10895 displayed for invisible text. It's not easy to handle that case
10896 below, and it's certainly not worth the effort since this is
10897 not a frequent case. */
10898 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
10901 IF_DEBUG (debug_method_add (w
, "twu1"));
10903 /* Display up to a row that can be reused. The variable
10904 last_text_row is set to the last row displayed that displays
10905 text. Note that it.vpos == 0 if or if not there is a
10906 header-line; it's not the same as the MATRIX_ROW_VPOS! */
10907 start_display (&it
, w
, new_start
);
10908 first_row_y
= it
.current_y
;
10909 w
->cursor
.vpos
= -1;
10910 last_text_row
= last_reused_text_row
= NULL
;
10912 while (it
.current_y
< it
.last_visible_y
10913 && IT_CHARPOS (it
) < CHARPOS (start
)
10914 && !fonts_changed_p
)
10915 if (display_line (&it
))
10916 last_text_row
= it
.glyph_row
- 1;
10918 /* A value of current_y < last_visible_y means that we stopped
10919 at the previous window start, which in turn means that we
10920 have at least one reusable row. */
10921 if (it
.current_y
< it
.last_visible_y
)
10923 /* IT.vpos always starts from 0; it counts text lines. */
10924 nrows_scrolled
= it
.vpos
;
10926 /* Find PT if not already found in the lines displayed. */
10927 if (w
->cursor
.vpos
< 0)
10929 int dy
= it
.current_y
- first_row_y
;
10931 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10932 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
10934 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
10935 dy
, nrows_scrolled
);
10938 clear_glyph_matrix (w
->desired_matrix
);
10943 /* Scroll the display. Do it before the current matrix is
10944 changed. The problem here is that update has not yet
10945 run, i.e. part of the current matrix is not up to date.
10946 scroll_run_hook will clear the cursor, and use the
10947 current matrix to get the height of the row the cursor is
10949 run
.current_y
= first_row_y
;
10950 run
.desired_y
= it
.current_y
;
10951 run
.height
= it
.last_visible_y
- it
.current_y
;
10953 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
10956 rif
->update_window_begin_hook (w
);
10957 rif
->clear_mouse_face (w
);
10958 rif
->scroll_run_hook (w
, &run
);
10959 rif
->update_window_end_hook (w
, 0, 0);
10963 /* Shift current matrix down by nrows_scrolled lines. */
10964 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
10965 rotate_matrix (w
->current_matrix
,
10967 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
10970 /* Disable lines that must be updated. */
10971 for (i
= 0; i
< it
.vpos
; ++i
)
10972 (start_row
+ i
)->enabled_p
= 0;
10974 /* Re-compute Y positions. */
10975 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10976 max_y
= it
.last_visible_y
;
10977 for (row
= start_row
+ nrows_scrolled
;
10981 row
->y
= it
.current_y
;
10982 row
->visible_height
= row
->height
;
10984 if (row
->y
< min_y
)
10985 row
->visible_height
-= min_y
- row
->y
;
10986 if (row
->y
+ row
->height
> max_y
)
10987 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
10989 it
.current_y
+= row
->height
;
10991 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10992 last_reused_text_row
= row
;
10993 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
10997 /* Disable lines in the current matrix which are now
10998 below the window. */
10999 for (++row
; row
< bottom_row
; ++row
)
11000 row
->enabled_p
= 0;
11003 /* Update window_end_pos etc.; last_reused_text_row is the last
11004 reused row from the current matrix containing text, if any.
11005 The value of last_text_row is the last displayed line
11006 containing text. */
11007 if (last_reused_text_row
)
11009 w
->window_end_bytepos
11010 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
11012 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_reused_text_row
));
11014 = make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
11015 w
->current_matrix
));
11017 else if (last_text_row
)
11019 w
->window_end_bytepos
11020 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
11022 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
11024 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
11028 /* This window must be completely empty. */
11029 w
->window_end_bytepos
= 0;
11030 w
->window_end_pos
= w
->window_end_vpos
= make_number (0);
11032 w
->window_end_valid
= Qnil
;
11034 /* Update hint: don't try scrolling again in update_window. */
11035 w
->desired_matrix
->no_scrolling_p
= 1;
11038 debug_method_add (w
, "try_window_reusing_current_matrix 1");
11042 else if (CHARPOS (new_start
) > CHARPOS (start
))
11044 struct glyph_row
*pt_row
, *row
;
11045 struct glyph_row
*first_reusable_row
;
11046 struct glyph_row
*first_row_to_display
;
11048 int yb
= window_text_bottom_y (w
);
11050 /* Find the row starting at new_start, if there is one. Don't
11051 reuse a partially visible line at the end. */
11052 first_reusable_row
= start_row
;
11053 while (first_reusable_row
->enabled_p
11054 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
11055 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
11056 < CHARPOS (new_start
)))
11057 ++first_reusable_row
;
11059 /* Give up if there is no row to reuse. */
11060 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
11061 || !first_reusable_row
->enabled_p
11062 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
11063 != CHARPOS (new_start
)))
11066 /* We can reuse fully visible rows beginning with
11067 first_reusable_row to the end of the window. Set
11068 first_row_to_display to the first row that cannot be reused.
11069 Set pt_row to the row containing point, if there is any. */
11071 for (first_row_to_display
= first_reusable_row
;
11072 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
11073 ++first_row_to_display
)
11075 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
11076 && PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
))
11077 pt_row
= first_row_to_display
;
11080 /* Start displaying at the start of first_row_to_display. */
11081 xassert (first_row_to_display
->y
< yb
);
11082 init_to_row_start (&it
, w
, first_row_to_display
);
11084 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
11086 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
11088 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
11089 + WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
11091 /* Display lines beginning with first_row_to_display in the
11092 desired matrix. Set last_text_row to the last row displayed
11093 that displays text. */
11094 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
11095 if (pt_row
== NULL
)
11096 w
->cursor
.vpos
= -1;
11097 last_text_row
= NULL
;
11098 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
11099 if (display_line (&it
))
11100 last_text_row
= it
.glyph_row
- 1;
11102 /* Give up If point isn't in a row displayed or reused. */
11103 if (w
->cursor
.vpos
< 0)
11105 clear_glyph_matrix (w
->desired_matrix
);
11109 /* If point is in a reused row, adjust y and vpos of the cursor
11113 w
->cursor
.vpos
-= MATRIX_ROW_VPOS (first_reusable_row
,
11114 w
->current_matrix
);
11115 w
->cursor
.y
-= first_reusable_row
->y
;
11118 /* Scroll the display. */
11119 run
.current_y
= first_reusable_row
->y
;
11120 run
.desired_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
11121 run
.height
= it
.last_visible_y
- run
.current_y
;
11122 dy
= run
.current_y
- run
.desired_y
;
11126 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11128 rif
->update_window_begin_hook (w
);
11129 rif
->clear_mouse_face (w
);
11130 rif
->scroll_run_hook (w
, &run
);
11131 rif
->update_window_end_hook (w
, 0, 0);
11135 /* Adjust Y positions of reused rows. */
11136 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
11137 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
11138 max_y
= it
.last_visible_y
;
11139 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
11142 row
->visible_height
= row
->height
;
11143 if (row
->y
< min_y
)
11144 row
->visible_height
-= min_y
- row
->y
;
11145 if (row
->y
+ row
->height
> max_y
)
11146 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
11149 /* Scroll the current matrix. */
11150 xassert (nrows_scrolled
> 0);
11151 rotate_matrix (w
->current_matrix
,
11153 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
11156 /* Disable rows not reused. */
11157 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
11158 row
->enabled_p
= 0;
11160 /* Adjust window end. A null value of last_text_row means that
11161 the window end is in reused rows which in turn means that
11162 only its vpos can have changed. */
11165 w
->window_end_bytepos
11166 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
11168 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
11170 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
11175 = make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
);
11178 w
->window_end_valid
= Qnil
;
11179 w
->desired_matrix
->no_scrolling_p
= 1;
11182 debug_method_add (w
, "try_window_reusing_current_matrix 2");
11192 /************************************************************************
11193 Window redisplay reusing current matrix when buffer has changed
11194 ************************************************************************/
11196 static struct glyph_row
*find_last_unchanged_at_beg_row
P_ ((struct window
*));
11197 static struct glyph_row
*find_first_unchanged_at_end_row
P_ ((struct window
*,
11199 static struct glyph_row
*
11200 find_last_row_displaying_text
P_ ((struct glyph_matrix
*, struct it
*,
11201 struct glyph_row
*));
11204 /* Return the last row in MATRIX displaying text. If row START is
11205 non-null, start searching with that row. IT gives the dimensions
11206 of the display. Value is null if matrix is empty; otherwise it is
11207 a pointer to the row found. */
11209 static struct glyph_row
*
11210 find_last_row_displaying_text (matrix
, it
, start
)
11211 struct glyph_matrix
*matrix
;
11213 struct glyph_row
*start
;
11215 struct glyph_row
*row
, *row_found
;
11217 /* Set row_found to the last row in IT->w's current matrix
11218 displaying text. The loop looks funny but think of partially
11221 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
11222 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
11224 xassert (row
->enabled_p
);
11226 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
11235 /* Return the last row in the current matrix of W that is not affected
11236 by changes at the start of current_buffer that occurred since W's
11237 current matrix was built. Value is null if no such row exists.
11239 BEG_UNCHANGED us the number of characters unchanged at the start of
11240 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
11241 first changed character in current_buffer. Characters at positions <
11242 BEG + BEG_UNCHANGED are at the same buffer positions as they were
11243 when the current matrix was built. */
11245 static struct glyph_row
*
11246 find_last_unchanged_at_beg_row (w
)
11249 int first_changed_pos
= BEG
+ BEG_UNCHANGED
;
11250 struct glyph_row
*row
;
11251 struct glyph_row
*row_found
= NULL
;
11252 int yb
= window_text_bottom_y (w
);
11254 /* Find the last row displaying unchanged text. */
11255 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
11256 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
11257 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
)
11259 if (/* If row ends before first_changed_pos, it is unchanged,
11260 except in some case. */
11261 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
11262 /* When row ends in ZV and we write at ZV it is not
11264 && !row
->ends_at_zv_p
11265 /* When first_changed_pos is the end of a continued line,
11266 row is not unchanged because it may be no longer
11268 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
11269 && row
->continued_p
))
11272 /* Stop if last visible row. */
11273 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
11283 /* Find the first glyph row in the current matrix of W that is not
11284 affected by changes at the end of current_buffer since the
11285 time W's current matrix was built.
11287 Return in *DELTA the number of chars by which buffer positions in
11288 unchanged text at the end of current_buffer must be adjusted.
11290 Return in *DELTA_BYTES the corresponding number of bytes.
11292 Value is null if no such row exists, i.e. all rows are affected by
11295 static struct glyph_row
*
11296 find_first_unchanged_at_end_row (w
, delta
, delta_bytes
)
11298 int *delta
, *delta_bytes
;
11300 struct glyph_row
*row
;
11301 struct glyph_row
*row_found
= NULL
;
11303 *delta
= *delta_bytes
= 0;
11305 /* Display must not have been paused, otherwise the current matrix
11306 is not up to date. */
11307 if (NILP (w
->window_end_valid
))
11310 /* A value of window_end_pos >= END_UNCHANGED means that the window
11311 end is in the range of changed text. If so, there is no
11312 unchanged row at the end of W's current matrix. */
11313 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
11316 /* Set row to the last row in W's current matrix displaying text. */
11317 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
11319 /* If matrix is entirely empty, no unchanged row exists. */
11320 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
11322 /* The value of row is the last glyph row in the matrix having a
11323 meaningful buffer position in it. The end position of row
11324 corresponds to window_end_pos. This allows us to translate
11325 buffer positions in the current matrix to current buffer
11326 positions for characters not in changed text. */
11327 int Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
11328 int Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
11329 int last_unchanged_pos
, last_unchanged_pos_old
;
11330 struct glyph_row
*first_text_row
11331 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
11333 *delta
= Z
- Z_old
;
11334 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
11336 /* Set last_unchanged_pos to the buffer position of the last
11337 character in the buffer that has not been changed. Z is the
11338 index + 1 of the last character in current_buffer, i.e. by
11339 subtracting END_UNCHANGED we get the index of the last
11340 unchanged character, and we have to add BEG to get its buffer
11342 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
11343 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
11345 /* Search backward from ROW for a row displaying a line that
11346 starts at a minimum position >= last_unchanged_pos_old. */
11347 for (; row
> first_text_row
; --row
)
11349 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
11352 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
11357 if (row_found
&& !MATRIX_ROW_DISPLAYS_TEXT_P (row_found
))
11364 /* Make sure that glyph rows in the current matrix of window W
11365 reference the same glyph memory as corresponding rows in the
11366 frame's frame matrix. This function is called after scrolling W's
11367 current matrix on a terminal frame in try_window_id and
11368 try_window_reusing_current_matrix. */
11371 sync_frame_with_window_matrix_rows (w
)
11374 struct frame
*f
= XFRAME (w
->frame
);
11375 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
11377 /* Preconditions: W must be a leaf window and full-width. Its frame
11378 must have a frame matrix. */
11379 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
11380 xassert (WINDOW_FULL_WIDTH_P (w
));
11381 xassert (!FRAME_WINDOW_P (f
));
11383 /* If W is a full-width window, glyph pointers in W's current matrix
11384 have, by definition, to be the same as glyph pointers in the
11385 corresponding frame matrix. Note that frame matrices have no
11386 marginal areas (see build_frame_matrix). */
11387 window_row
= w
->current_matrix
->rows
;
11388 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
11389 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
11390 while (window_row
< window_row_end
)
11392 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
11393 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
11395 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
11396 frame_row
->glyphs
[TEXT_AREA
] = start
;
11397 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
11398 frame_row
->glyphs
[LAST_AREA
] = end
;
11400 /* Disable frame rows whose corresponding window rows have
11401 been disabled in try_window_id. */
11402 if (!window_row
->enabled_p
)
11403 frame_row
->enabled_p
= 0;
11405 ++window_row
, ++frame_row
;
11410 /* Find the glyph row in window W containing CHARPOS. Consider all
11411 rows between START and END (not inclusive). END null means search
11412 all rows to the end of the display area of W. Value is the row
11413 containing CHARPOS or null. */
11416 row_containing_pos (w
, charpos
, start
, end
, dy
)
11419 struct glyph_row
*start
, *end
;
11422 struct glyph_row
*row
= start
;
11425 /* If we happen to start on a header-line, skip that. */
11426 if (row
->mode_line_p
)
11429 if ((end
&& row
>= end
) || !row
->enabled_p
)
11432 last_y
= window_text_bottom_y (w
) - dy
;
11434 while ((end
== NULL
|| row
< end
)
11435 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
11436 && (MATRIX_ROW_END_CHARPOS (row
) < charpos
11437 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
11438 /* The end position of a row equals the start
11439 position of the next row. If CHARPOS is there, we
11440 would rather display it in the next line, except
11441 when this line ends in ZV. */
11442 && !row
->ends_at_zv_p
11443 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))
11446 /* Give up if CHARPOS not found. */
11447 if ((end
&& row
>= end
)
11448 || charpos
< MATRIX_ROW_START_CHARPOS (row
)
11449 || charpos
> MATRIX_ROW_END_CHARPOS (row
))
11456 /* Try to redisplay window W by reusing its existing display. W's
11457 current matrix must be up to date when this function is called,
11458 i.e. window_end_valid must not be nil.
11462 1 if display has been updated
11463 0 if otherwise unsuccessful
11464 -1 if redisplay with same window start is known not to succeed
11466 The following steps are performed:
11468 1. Find the last row in the current matrix of W that is not
11469 affected by changes at the start of current_buffer. If no such row
11472 2. Find the first row in W's current matrix that is not affected by
11473 changes at the end of current_buffer. Maybe there is no such row.
11475 3. Display lines beginning with the row + 1 found in step 1 to the
11476 row found in step 2 or, if step 2 didn't find a row, to the end of
11479 4. If cursor is not known to appear on the window, give up.
11481 5. If display stopped at the row found in step 2, scroll the
11482 display and current matrix as needed.
11484 6. Maybe display some lines at the end of W, if we must. This can
11485 happen under various circumstances, like a partially visible line
11486 becoming fully visible, or because newly displayed lines are displayed
11487 in smaller font sizes.
11489 7. Update W's window end information. */
11495 struct frame
*f
= XFRAME (w
->frame
);
11496 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
11497 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
11498 struct glyph_row
*last_unchanged_at_beg_row
;
11499 struct glyph_row
*first_unchanged_at_end_row
;
11500 struct glyph_row
*row
;
11501 struct glyph_row
*bottom_row
;
11504 int delta
= 0, delta_bytes
= 0, stop_pos
, dvpos
, dy
;
11505 struct text_pos start_pos
;
11507 int first_unchanged_at_end_vpos
= 0;
11508 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
11509 struct text_pos start
;
11510 int first_changed_charpos
, last_changed_charpos
;
11513 if (inhibit_try_window_id
)
11517 /* This is handy for debugging. */
11519 #define GIVE_UP(X) \
11521 fprintf (stderr, "try_window_id give up %d\n", (X)); \
11525 #define GIVE_UP(X) return 0
11528 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
11530 /* Don't use this for mini-windows because these can show
11531 messages and mini-buffers, and we don't handle that here. */
11532 if (MINI_WINDOW_P (w
))
11535 /* This flag is used to prevent redisplay optimizations. */
11536 if (windows_or_buffers_changed
|| cursor_type_changed
)
11539 /* Verify that narrowing has not changed.
11540 Also verify that we were not told to prevent redisplay optimizations.
11541 It would be nice to further
11542 reduce the number of cases where this prevents try_window_id. */
11543 if (current_buffer
->clip_changed
11544 || current_buffer
->prevent_redisplay_optimizations_p
)
11547 /* Window must either use window-based redisplay or be full width. */
11548 if (!FRAME_WINDOW_P (f
)
11549 && (!line_ins_del_ok
11550 || !WINDOW_FULL_WIDTH_P (w
)))
11553 /* Give up if point is not known NOT to appear in W. */
11554 if (PT
< CHARPOS (start
))
11557 /* Another way to prevent redisplay optimizations. */
11558 if (XFASTINT (w
->last_modified
) == 0)
11561 /* Verify that window is not hscrolled. */
11562 if (XFASTINT (w
->hscroll
) != 0)
11565 /* Verify that display wasn't paused. */
11566 if (NILP (w
->window_end_valid
))
11569 /* Can't use this if highlighting a region because a cursor movement
11570 will do more than just set the cursor. */
11571 if (!NILP (Vtransient_mark_mode
)
11572 && !NILP (current_buffer
->mark_active
))
11575 /* Likewise if highlighting trailing whitespace. */
11576 if (!NILP (Vshow_trailing_whitespace
))
11579 /* Likewise if showing a region. */
11580 if (!NILP (w
->region_showing
))
11583 /* Can use this if overlay arrow position and or string have changed. */
11584 if (!EQ (last_arrow_position
, COERCE_MARKER (Voverlay_arrow_position
))
11585 || !EQ (last_arrow_string
, Voverlay_arrow_string
))
11589 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
11590 only if buffer has really changed. The reason is that the gap is
11591 initially at Z for freshly visited files. The code below would
11592 set end_unchanged to 0 in that case. */
11593 if (MODIFF
> SAVE_MODIFF
11594 /* This seems to happen sometimes after saving a buffer. */
11595 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
11597 if (GPT
- BEG
< BEG_UNCHANGED
)
11598 BEG_UNCHANGED
= GPT
- BEG
;
11599 if (Z
- GPT
< END_UNCHANGED
)
11600 END_UNCHANGED
= Z
- GPT
;
11603 /* The position of the first and last character that has been changed. */
11604 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
11605 last_changed_charpos
= Z
- END_UNCHANGED
;
11607 /* If window starts after a line end, and the last change is in
11608 front of that newline, then changes don't affect the display.
11609 This case happens with stealth-fontification. Note that although
11610 the display is unchanged, glyph positions in the matrix have to
11611 be adjusted, of course. */
11612 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
11613 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
11614 && ((last_changed_charpos
< CHARPOS (start
)
11615 && CHARPOS (start
) == BEGV
)
11616 || (last_changed_charpos
< CHARPOS (start
) - 1
11617 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
11619 int Z_old
, delta
, Z_BYTE_old
, delta_bytes
;
11620 struct glyph_row
*r0
;
11622 /* Compute how many chars/bytes have been added to or removed
11623 from the buffer. */
11624 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
11625 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
11627 delta_bytes
= Z_BYTE
- Z_BYTE_old
;
11629 /* Give up if PT is not in the window. Note that it already has
11630 been checked at the start of try_window_id that PT is not in
11631 front of the window start. */
11632 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + delta
)
11635 /* If window start is unchanged, we can reuse the whole matrix
11636 as is, after adjusting glyph positions. No need to compute
11637 the window end again, since its offset from Z hasn't changed. */
11638 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
11639 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + delta
11640 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + delta_bytes
)
11642 /* Adjust positions in the glyph matrix. */
11643 if (delta
|| delta_bytes
)
11645 struct glyph_row
*r1
11646 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
11647 increment_matrix_positions (w
->current_matrix
,
11648 MATRIX_ROW_VPOS (r0
, current_matrix
),
11649 MATRIX_ROW_VPOS (r1
, current_matrix
),
11650 delta
, delta_bytes
);
11653 /* Set the cursor. */
11654 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
11655 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
11660 /* Handle the case that changes are all below what is displayed in
11661 the window, and that PT is in the window. This shortcut cannot
11662 be taken if ZV is visible in the window, and text has been added
11663 there that is visible in the window. */
11664 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
11665 /* ZV is not visible in the window, or there are no
11666 changes at ZV, actually. */
11667 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
11668 || first_changed_charpos
== last_changed_charpos
))
11670 struct glyph_row
*r0
;
11672 /* Give up if PT is not in the window. Note that it already has
11673 been checked at the start of try_window_id that PT is not in
11674 front of the window start. */
11675 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
11678 /* If window start is unchanged, we can reuse the whole matrix
11679 as is, without changing glyph positions since no text has
11680 been added/removed in front of the window end. */
11681 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
11682 if (TEXT_POS_EQUAL_P (start
, r0
->start
.pos
))
11684 /* We have to compute the window end anew since text
11685 can have been added/removed after it. */
11687 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
11688 w
->window_end_bytepos
11689 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
11691 /* Set the cursor. */
11692 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
11693 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
11698 /* Give up if window start is in the changed area.
11700 The condition used to read
11702 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
11704 but why that was tested escapes me at the moment. */
11705 if (CHARPOS (start
) >= first_changed_charpos
11706 && CHARPOS (start
) <= last_changed_charpos
)
11709 /* Check that window start agrees with the start of the first glyph
11710 row in its current matrix. Check this after we know the window
11711 start is not in changed text, otherwise positions would not be
11713 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
11714 if (!TEXT_POS_EQUAL_P (start
, row
->start
.pos
))
11717 /* Give up if the window ends in strings. Overlay strings
11718 at the end are difficult to handle, so don't try. */
11719 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
11720 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
11723 /* Compute the position at which we have to start displaying new
11724 lines. Some of the lines at the top of the window might be
11725 reusable because they are not displaying changed text. Find the
11726 last row in W's current matrix not affected by changes at the
11727 start of current_buffer. Value is null if changes start in the
11728 first line of window. */
11729 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
11730 if (last_unchanged_at_beg_row
)
11732 /* Avoid starting to display in the moddle of a character, a TAB
11733 for instance. This is easier than to set up the iterator
11734 exactly, and it's not a frequent case, so the additional
11735 effort wouldn't really pay off. */
11736 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
11737 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
11738 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
11739 --last_unchanged_at_beg_row
;
11741 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
11744 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
11746 start_pos
= it
.current
.pos
;
11748 /* Start displaying new lines in the desired matrix at the same
11749 vpos we would use in the current matrix, i.e. below
11750 last_unchanged_at_beg_row. */
11751 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
11753 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
11754 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
11756 xassert (it
.hpos
== 0 && it
.current_x
== 0);
11760 /* There are no reusable lines at the start of the window.
11761 Start displaying in the first line. */
11762 start_display (&it
, w
, start
);
11763 start_pos
= it
.current
.pos
;
11766 /* Find the first row that is not affected by changes at the end of
11767 the buffer. Value will be null if there is no unchanged row, in
11768 which case we must redisplay to the end of the window. delta
11769 will be set to the value by which buffer positions beginning with
11770 first_unchanged_at_end_row have to be adjusted due to text
11772 first_unchanged_at_end_row
11773 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
11774 IF_DEBUG (debug_delta
= delta
);
11775 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
11777 /* Set stop_pos to the buffer position up to which we will have to
11778 display new lines. If first_unchanged_at_end_row != NULL, this
11779 is the buffer position of the start of the line displayed in that
11780 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
11781 that we don't stop at a buffer position. */
11783 if (first_unchanged_at_end_row
)
11785 xassert (last_unchanged_at_beg_row
== NULL
11786 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
11788 /* If this is a continuation line, move forward to the next one
11789 that isn't. Changes in lines above affect this line.
11790 Caution: this may move first_unchanged_at_end_row to a row
11791 not displaying text. */
11792 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
11793 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
11794 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
11795 < it
.last_visible_y
))
11796 ++first_unchanged_at_end_row
;
11798 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
11799 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
11800 >= it
.last_visible_y
))
11801 first_unchanged_at_end_row
= NULL
;
11804 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
11806 first_unchanged_at_end_vpos
11807 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
11808 xassert (stop_pos
>= Z
- END_UNCHANGED
);
11811 else if (last_unchanged_at_beg_row
== NULL
)
11817 /* Either there is no unchanged row at the end, or the one we have
11818 now displays text. This is a necessary condition for the window
11819 end pos calculation at the end of this function. */
11820 xassert (first_unchanged_at_end_row
== NULL
11821 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
11823 debug_last_unchanged_at_beg_vpos
11824 = (last_unchanged_at_beg_row
11825 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
11827 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
11829 #endif /* GLYPH_DEBUG != 0 */
11832 /* Display new lines. Set last_text_row to the last new line
11833 displayed which has text on it, i.e. might end up as being the
11834 line where the window_end_vpos is. */
11835 w
->cursor
.vpos
= -1;
11836 last_text_row
= NULL
;
11837 overlay_arrow_seen
= 0;
11838 while (it
.current_y
< it
.last_visible_y
11839 && !fonts_changed_p
11840 && (first_unchanged_at_end_row
== NULL
11841 || IT_CHARPOS (it
) < stop_pos
))
11843 if (display_line (&it
))
11844 last_text_row
= it
.glyph_row
- 1;
11847 if (fonts_changed_p
)
11851 /* Compute differences in buffer positions, y-positions etc. for
11852 lines reused at the bottom of the window. Compute what we can
11854 if (first_unchanged_at_end_row
11855 /* No lines reused because we displayed everything up to the
11856 bottom of the window. */
11857 && it
.current_y
< it
.last_visible_y
)
11860 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
11862 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
11863 run
.current_y
= first_unchanged_at_end_row
->y
;
11864 run
.desired_y
= run
.current_y
+ dy
;
11865 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
11869 delta
= dvpos
= dy
= run
.current_y
= run
.desired_y
= run
.height
= 0;
11870 first_unchanged_at_end_row
= NULL
;
11872 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
11875 /* Find the cursor if not already found. We have to decide whether
11876 PT will appear on this window (it sometimes doesn't, but this is
11877 not a very frequent case.) This decision has to be made before
11878 the current matrix is altered. A value of cursor.vpos < 0 means
11879 that PT is either in one of the lines beginning at
11880 first_unchanged_at_end_row or below the window. Don't care for
11881 lines that might be displayed later at the window end; as
11882 mentioned, this is not a frequent case. */
11883 if (w
->cursor
.vpos
< 0)
11885 /* Cursor in unchanged rows at the top? */
11886 if (PT
< CHARPOS (start_pos
)
11887 && last_unchanged_at_beg_row
)
11889 row
= row_containing_pos (w
, PT
,
11890 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
11891 last_unchanged_at_beg_row
+ 1, 0);
11893 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
11896 /* Start from first_unchanged_at_end_row looking for PT. */
11897 else if (first_unchanged_at_end_row
)
11899 row
= row_containing_pos (w
, PT
- delta
,
11900 first_unchanged_at_end_row
, NULL
, 0);
11902 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
11903 delta_bytes
, dy
, dvpos
);
11906 /* Give up if cursor was not found. */
11907 if (w
->cursor
.vpos
< 0)
11909 clear_glyph_matrix (w
->desired_matrix
);
11914 /* Don't let the cursor end in the scroll margins. */
11916 int this_scroll_margin
, cursor_height
;
11918 this_scroll_margin
= max (0, scroll_margin
);
11919 this_scroll_margin
= min (this_scroll_margin
,
11920 XFASTINT (w
->height
) / 4);
11921 this_scroll_margin
*= CANON_Y_UNIT (it
.f
);
11922 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
11924 if ((w
->cursor
.y
< this_scroll_margin
11925 && CHARPOS (start
) > BEGV
)
11926 /* Don't take scroll margin into account at the bottom because
11927 old redisplay didn't do it either. */
11928 || w
->cursor
.y
+ cursor_height
> it
.last_visible_y
)
11930 w
->cursor
.vpos
= -1;
11931 clear_glyph_matrix (w
->desired_matrix
);
11936 /* Scroll the display. Do it before changing the current matrix so
11937 that xterm.c doesn't get confused about where the cursor glyph is
11939 if (dy
&& run
.height
)
11943 if (FRAME_WINDOW_P (f
))
11945 rif
->update_window_begin_hook (w
);
11946 rif
->clear_mouse_face (w
);
11947 rif
->scroll_run_hook (w
, &run
);
11948 rif
->update_window_end_hook (w
, 0, 0);
11952 /* Terminal frame. In this case, dvpos gives the number of
11953 lines to scroll by; dvpos < 0 means scroll up. */
11954 int first_unchanged_at_end_vpos
11955 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
11956 int from
= XFASTINT (w
->top
) + first_unchanged_at_end_vpos
;
11957 int end
= (XFASTINT (w
->top
)
11958 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
11959 + window_internal_height (w
));
11961 /* Perform the operation on the screen. */
11964 /* Scroll last_unchanged_at_beg_row to the end of the
11965 window down dvpos lines. */
11966 set_terminal_window (end
);
11968 /* On dumb terminals delete dvpos lines at the end
11969 before inserting dvpos empty lines. */
11970 if (!scroll_region_ok
)
11971 ins_del_lines (end
- dvpos
, -dvpos
);
11973 /* Insert dvpos empty lines in front of
11974 last_unchanged_at_beg_row. */
11975 ins_del_lines (from
, dvpos
);
11977 else if (dvpos
< 0)
11979 /* Scroll up last_unchanged_at_beg_vpos to the end of
11980 the window to last_unchanged_at_beg_vpos - |dvpos|. */
11981 set_terminal_window (end
);
11983 /* Delete dvpos lines in front of
11984 last_unchanged_at_beg_vpos. ins_del_lines will set
11985 the cursor to the given vpos and emit |dvpos| delete
11987 ins_del_lines (from
+ dvpos
, dvpos
);
11989 /* On a dumb terminal insert dvpos empty lines at the
11991 if (!scroll_region_ok
)
11992 ins_del_lines (end
+ dvpos
, -dvpos
);
11995 set_terminal_window (0);
12001 /* Shift reused rows of the current matrix to the right position.
12002 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
12004 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
12005 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
12008 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
12009 bottom_vpos
, dvpos
);
12010 enable_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
12013 else if (dvpos
> 0)
12015 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
12016 bottom_vpos
, dvpos
);
12017 enable_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
12018 first_unchanged_at_end_vpos
+ dvpos
, 0);
12021 /* For frame-based redisplay, make sure that current frame and window
12022 matrix are in sync with respect to glyph memory. */
12023 if (!FRAME_WINDOW_P (f
))
12024 sync_frame_with_window_matrix_rows (w
);
12026 /* Adjust buffer positions in reused rows. */
12028 increment_matrix_positions (current_matrix
,
12029 first_unchanged_at_end_vpos
+ dvpos
,
12030 bottom_vpos
, delta
, delta_bytes
);
12032 /* Adjust Y positions. */
12034 shift_glyph_matrix (w
, current_matrix
,
12035 first_unchanged_at_end_vpos
+ dvpos
,
12038 if (first_unchanged_at_end_row
)
12039 first_unchanged_at_end_row
+= dvpos
;
12041 /* If scrolling up, there may be some lines to display at the end of
12043 last_text_row_at_end
= NULL
;
12046 /* Scrolling up can leave for example a partially visible line
12047 at the end of the window to be redisplayed. */
12048 /* Set last_row to the glyph row in the current matrix where the
12049 window end line is found. It has been moved up or down in
12050 the matrix by dvpos. */
12051 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
12052 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
12054 /* If last_row is the window end line, it should display text. */
12055 xassert (last_row
->displays_text_p
);
12057 /* If window end line was partially visible before, begin
12058 displaying at that line. Otherwise begin displaying with the
12059 line following it. */
12060 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
12062 init_to_row_start (&it
, w
, last_row
);
12063 it
.vpos
= last_vpos
;
12064 it
.current_y
= last_row
->y
;
12068 init_to_row_end (&it
, w
, last_row
);
12069 it
.vpos
= 1 + last_vpos
;
12070 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
12074 /* We may start in a continuation line. If so, we have to
12075 get the right continuation_lines_width and current_x. */
12076 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
12077 it
.hpos
= it
.current_x
= 0;
12079 /* Display the rest of the lines at the window end. */
12080 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
12081 while (it
.current_y
< it
.last_visible_y
12082 && !fonts_changed_p
)
12084 /* Is it always sure that the display agrees with lines in
12085 the current matrix? I don't think so, so we mark rows
12086 displayed invalid in the current matrix by setting their
12087 enabled_p flag to zero. */
12088 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
12089 if (display_line (&it
))
12090 last_text_row_at_end
= it
.glyph_row
- 1;
12094 /* Update window_end_pos and window_end_vpos. */
12095 if (first_unchanged_at_end_row
12096 && first_unchanged_at_end_row
->y
< it
.last_visible_y
12097 && !last_text_row_at_end
)
12099 /* Window end line if one of the preserved rows from the current
12100 matrix. Set row to the last row displaying text in current
12101 matrix starting at first_unchanged_at_end_row, after
12103 xassert (first_unchanged_at_end_row
->displays_text_p
);
12104 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
12105 first_unchanged_at_end_row
);
12106 xassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
12108 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
12109 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
12111 = make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
));
12112 xassert (w
->window_end_bytepos
>= 0);
12113 IF_DEBUG (debug_method_add (w
, "A"));
12115 else if (last_text_row_at_end
)
12118 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
));
12119 w
->window_end_bytepos
12120 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
12122 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end
, desired_matrix
));
12123 xassert (w
->window_end_bytepos
>= 0);
12124 IF_DEBUG (debug_method_add (w
, "B"));
12126 else if (last_text_row
)
12128 /* We have displayed either to the end of the window or at the
12129 end of the window, i.e. the last row with text is to be found
12130 in the desired matrix. */
12132 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
12133 w
->window_end_bytepos
12134 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
12136 = make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
));
12137 xassert (w
->window_end_bytepos
>= 0);
12139 else if (first_unchanged_at_end_row
== NULL
12140 && last_text_row
== NULL
12141 && last_text_row_at_end
== NULL
)
12143 /* Displayed to end of window, but no line containing text was
12144 displayed. Lines were deleted at the end of the window. */
12145 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
12146 int vpos
= XFASTINT (w
->window_end_vpos
);
12147 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
12148 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
12151 row
== NULL
&& vpos
>= first_vpos
;
12152 --vpos
, --current_row
, --desired_row
)
12154 if (desired_row
->enabled_p
)
12156 if (desired_row
->displays_text_p
)
12159 else if (current_row
->displays_text_p
)
12163 xassert (row
!= NULL
);
12164 w
->window_end_vpos
= make_number (vpos
+ 1);
12165 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
12166 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
12167 xassert (w
->window_end_bytepos
>= 0);
12168 IF_DEBUG (debug_method_add (w
, "C"));
12173 #if 0 /* This leads to problems, for instance when the cursor is
12174 at ZV, and the cursor line displays no text. */
12175 /* Disable rows below what's displayed in the window. This makes
12176 debugging easier. */
12177 enable_glyph_matrix_rows (current_matrix
,
12178 XFASTINT (w
->window_end_vpos
) + 1,
12182 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
12183 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
12185 /* Record that display has not been completed. */
12186 w
->window_end_valid
= Qnil
;
12187 w
->desired_matrix
->no_scrolling_p
= 1;
12195 /***********************************************************************
12196 More debugging support
12197 ***********************************************************************/
12201 void dump_glyph_row
P_ ((struct glyph_row
*, int, int));
12202 void dump_glyph_matrix
P_ ((struct glyph_matrix
*, int));
12203 void dump_glyph
P_ ((struct glyph_row
*, struct glyph
*, int));
12206 /* Dump the contents of glyph matrix MATRIX on stderr.
12208 GLYPHS 0 means don't show glyph contents.
12209 GLYPHS 1 means show glyphs in short form
12210 GLYPHS > 1 means show glyphs in long form. */
12213 dump_glyph_matrix (matrix
, glyphs
)
12214 struct glyph_matrix
*matrix
;
12218 for (i
= 0; i
< matrix
->nrows
; ++i
)
12219 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
12223 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
12224 the glyph row and area where the glyph comes from. */
12227 dump_glyph (row
, glyph
, area
)
12228 struct glyph_row
*row
;
12229 struct glyph
*glyph
;
12232 if (glyph
->type
== CHAR_GLYPH
)
12235 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
12236 glyph
- row
->glyphs
[TEXT_AREA
],
12239 (BUFFERP (glyph
->object
)
12241 : (STRINGP (glyph
->object
)
12244 glyph
->pixel_width
,
12246 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
12250 glyph
->left_box_line_p
,
12251 glyph
->right_box_line_p
);
12253 else if (glyph
->type
== STRETCH_GLYPH
)
12256 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
12257 glyph
- row
->glyphs
[TEXT_AREA
],
12260 (BUFFERP (glyph
->object
)
12262 : (STRINGP (glyph
->object
)
12265 glyph
->pixel_width
,
12269 glyph
->left_box_line_p
,
12270 glyph
->right_box_line_p
);
12272 else if (glyph
->type
== IMAGE_GLYPH
)
12275 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
12276 glyph
- row
->glyphs
[TEXT_AREA
],
12279 (BUFFERP (glyph
->object
)
12281 : (STRINGP (glyph
->object
)
12284 glyph
->pixel_width
,
12288 glyph
->left_box_line_p
,
12289 glyph
->right_box_line_p
);
12294 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
12295 GLYPHS 0 means don't show glyph contents.
12296 GLYPHS 1 means show glyphs in short form
12297 GLYPHS > 1 means show glyphs in long form. */
12300 dump_glyph_row (row
, vpos
, glyphs
)
12301 struct glyph_row
*row
;
12306 fprintf (stderr
, "Row Start End Used oEI><O\\CTZFesm X Y W H V A P\n");
12307 fprintf (stderr
, "=======================================================================\n");
12309 fprintf (stderr
, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d%1.1d\
12310 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
12312 MATRIX_ROW_START_CHARPOS (row
),
12313 MATRIX_ROW_END_CHARPOS (row
),
12314 row
->used
[TEXT_AREA
],
12315 row
->contains_overlapping_glyphs_p
,
12317 row
->truncated_on_left_p
,
12318 row
->truncated_on_right_p
,
12319 row
->overlay_arrow_p
,
12321 MATRIX_ROW_CONTINUATION_LINE_P (row
),
12322 row
->displays_text_p
,
12325 row
->ends_in_middle_of_char_p
,
12326 row
->starts_in_middle_of_char_p
,
12332 row
->visible_height
,
12335 fprintf (stderr
, "%9d %5d\t%5d\n", row
->start
.overlay_string_index
,
12336 row
->end
.overlay_string_index
,
12337 row
->continuation_lines_width
);
12338 fprintf (stderr
, "%9d %5d\n",
12339 CHARPOS (row
->start
.string_pos
),
12340 CHARPOS (row
->end
.string_pos
));
12341 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
12342 row
->end
.dpvec_index
);
12349 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
12351 struct glyph
*glyph
= row
->glyphs
[area
];
12352 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
12354 /* Glyph for a line end in text. */
12355 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
12358 if (glyph
< glyph_end
)
12359 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
12361 for (; glyph
< glyph_end
; ++glyph
)
12362 dump_glyph (row
, glyph
, area
);
12365 else if (glyphs
== 1)
12369 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
12371 char *s
= (char *) alloca (row
->used
[area
] + 1);
12374 for (i
= 0; i
< row
->used
[area
]; ++i
)
12376 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
12377 if (glyph
->type
== CHAR_GLYPH
12378 && glyph
->u
.ch
< 0x80
12379 && glyph
->u
.ch
>= ' ')
12380 s
[i
] = glyph
->u
.ch
;
12386 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
12392 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
12393 Sdump_glyph_matrix
, 0, 1, "p",
12394 doc
: /* Dump the current matrix of the selected window to stderr.
12395 Shows contents of glyph row structures. With non-nil
12396 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
12397 glyphs in short form, otherwise show glyphs in long form. */)
12399 Lisp_Object glyphs
;
12401 struct window
*w
= XWINDOW (selected_window
);
12402 struct buffer
*buffer
= XBUFFER (w
->buffer
);
12404 fprintf (stderr
, "PT = %d, BEGV = %d. ZV = %d\n",
12405 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
12406 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
12407 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
12408 fprintf (stderr
, "=============================================\n");
12409 dump_glyph_matrix (w
->current_matrix
,
12410 NILP (glyphs
) ? 0 : XINT (glyphs
));
12415 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
12416 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
12419 struct frame
*f
= XFRAME (selected_frame
);
12420 dump_glyph_matrix (f
->current_matrix
, 1);
12425 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
12426 doc
: /* Dump glyph row ROW to stderr.
12427 GLYPH 0 means don't dump glyphs.
12428 GLYPH 1 means dump glyphs in short form.
12429 GLYPH > 1 or omitted means dump glyphs in long form. */)
12431 Lisp_Object row
, glyphs
;
12433 struct glyph_matrix
*matrix
;
12436 CHECK_NUMBER (row
);
12437 matrix
= XWINDOW (selected_window
)->current_matrix
;
12439 if (vpos
>= 0 && vpos
< matrix
->nrows
)
12440 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
12442 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
12447 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
12448 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
12449 GLYPH 0 means don't dump glyphs.
12450 GLYPH 1 means dump glyphs in short form.
12451 GLYPH > 1 or omitted means dump glyphs in long form. */)
12453 Lisp_Object row
, glyphs
;
12455 struct frame
*sf
= SELECTED_FRAME ();
12456 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
12459 CHECK_NUMBER (row
);
12461 if (vpos
>= 0 && vpos
< m
->nrows
)
12462 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
12463 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
12468 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
12469 doc
: /* Toggle tracing of redisplay.
12470 With ARG, turn tracing on if and only if ARG is positive. */)
12475 trace_redisplay_p
= !trace_redisplay_p
;
12478 arg
= Fprefix_numeric_value (arg
);
12479 trace_redisplay_p
= XINT (arg
) > 0;
12486 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
12487 doc
: /* Like `format', but print result to stderr.
12488 usage: (trace-to-stderr STRING &rest OBJECTS) */)
12493 Lisp_Object s
= Fformat (nargs
, args
);
12494 fprintf (stderr
, "%s", SDATA (s
));
12498 #endif /* GLYPH_DEBUG */
12502 /***********************************************************************
12503 Building Desired Matrix Rows
12504 ***********************************************************************/
12506 /* Return a temporary glyph row holding the glyphs of an overlay
12507 arrow. Only used for non-window-redisplay windows. */
12509 static struct glyph_row
*
12510 get_overlay_arrow_glyph_row (w
)
12513 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
12514 struct buffer
*buffer
= XBUFFER (w
->buffer
);
12515 struct buffer
*old
= current_buffer
;
12516 const unsigned char *arrow_string
= SDATA (Voverlay_arrow_string
);
12517 int arrow_len
= SCHARS (Voverlay_arrow_string
);
12518 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
12519 const unsigned char *p
;
12522 int n_glyphs_before
;
12524 set_buffer_temp (buffer
);
12525 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
12526 it
.glyph_row
->used
[TEXT_AREA
] = 0;
12527 SET_TEXT_POS (it
.position
, 0, 0);
12529 multibyte_p
= !NILP (buffer
->enable_multibyte_characters
);
12531 while (p
< arrow_end
)
12533 Lisp_Object face
, ilisp
;
12535 /* Get the next character. */
12537 it
.c
= string_char_and_length (p
, arrow_len
, &it
.len
);
12539 it
.c
= *p
, it
.len
= 1;
12542 /* Get its face. */
12543 ilisp
= make_number (p
- arrow_string
);
12544 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
12545 it
.face_id
= compute_char_face (f
, it
.c
, face
);
12547 /* Compute its width, get its glyphs. */
12548 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
12549 SET_TEXT_POS (it
.position
, -1, -1);
12550 PRODUCE_GLYPHS (&it
);
12552 /* If this character doesn't fit any more in the line, we have
12553 to remove some glyphs. */
12554 if (it
.current_x
> it
.last_visible_x
)
12556 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
12561 set_buffer_temp (old
);
12562 return it
.glyph_row
;
12566 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
12567 glyphs are only inserted for terminal frames since we can't really
12568 win with truncation glyphs when partially visible glyphs are
12569 involved. Which glyphs to insert is determined by
12570 produce_special_glyphs. */
12573 insert_left_trunc_glyphs (it
)
12576 struct it truncate_it
;
12577 struct glyph
*from
, *end
, *to
, *toend
;
12579 xassert (!FRAME_WINDOW_P (it
->f
));
12581 /* Get the truncation glyphs. */
12583 truncate_it
.current_x
= 0;
12584 truncate_it
.face_id
= DEFAULT_FACE_ID
;
12585 truncate_it
.glyph_row
= &scratch_glyph_row
;
12586 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
12587 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
12588 truncate_it
.object
= make_number (0);
12589 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
12591 /* Overwrite glyphs from IT with truncation glyphs. */
12592 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
12593 end
= from
+ truncate_it
.glyph_row
->used
[TEXT_AREA
];
12594 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
12595 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
12600 /* There may be padding glyphs left over. Overwrite them too. */
12601 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
12603 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
12609 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
12613 /* Compute the pixel height and width of IT->glyph_row.
12615 Most of the time, ascent and height of a display line will be equal
12616 to the max_ascent and max_height values of the display iterator
12617 structure. This is not the case if
12619 1. We hit ZV without displaying anything. In this case, max_ascent
12620 and max_height will be zero.
12622 2. We have some glyphs that don't contribute to the line height.
12623 (The glyph row flag contributes_to_line_height_p is for future
12624 pixmap extensions).
12626 The first case is easily covered by using default values because in
12627 these cases, the line height does not really matter, except that it
12628 must not be zero. */
12631 compute_line_metrics (it
)
12634 struct glyph_row
*row
= it
->glyph_row
;
12637 if (FRAME_WINDOW_P (it
->f
))
12639 int i
, min_y
, max_y
;
12641 /* The line may consist of one space only, that was added to
12642 place the cursor on it. If so, the row's height hasn't been
12644 if (row
->height
== 0)
12646 if (it
->max_ascent
+ it
->max_descent
== 0)
12647 it
->max_descent
= it
->max_phys_descent
= CANON_Y_UNIT (it
->f
);
12648 row
->ascent
= it
->max_ascent
;
12649 row
->height
= it
->max_ascent
+ it
->max_descent
;
12650 row
->phys_ascent
= it
->max_phys_ascent
;
12651 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
12654 /* Compute the width of this line. */
12655 row
->pixel_width
= row
->x
;
12656 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
12657 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
12659 xassert (row
->pixel_width
>= 0);
12660 xassert (row
->ascent
>= 0 && row
->height
> 0);
12662 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
12663 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
12665 /* If first line's physical ascent is larger than its logical
12666 ascent, use the physical ascent, and make the row taller.
12667 This makes accented characters fully visible. */
12668 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
12669 && row
->phys_ascent
> row
->ascent
)
12671 row
->height
+= row
->phys_ascent
- row
->ascent
;
12672 row
->ascent
= row
->phys_ascent
;
12675 /* Compute how much of the line is visible. */
12676 row
->visible_height
= row
->height
;
12678 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (it
->w
);
12679 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (it
->w
);
12681 if (row
->y
< min_y
)
12682 row
->visible_height
-= min_y
- row
->y
;
12683 if (row
->y
+ row
->height
> max_y
)
12684 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
12688 row
->pixel_width
= row
->used
[TEXT_AREA
];
12689 if (row
->continued_p
)
12690 row
->pixel_width
-= it
->continuation_pixel_width
;
12691 else if (row
->truncated_on_right_p
)
12692 row
->pixel_width
-= it
->truncation_pixel_width
;
12693 row
->ascent
= row
->phys_ascent
= 0;
12694 row
->height
= row
->phys_height
= row
->visible_height
= 1;
12697 /* Compute a hash code for this row. */
12699 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
12700 for (i
= 0; i
< row
->used
[area
]; ++i
)
12701 row
->hash
= ((((row
->hash
<< 4) + (row
->hash
>> 24)) & 0x0fffffff)
12702 + row
->glyphs
[area
][i
].u
.val
12703 + row
->glyphs
[area
][i
].face_id
12704 + row
->glyphs
[area
][i
].padding_p
12705 + (row
->glyphs
[area
][i
].type
<< 2));
12707 it
->max_ascent
= it
->max_descent
= 0;
12708 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
12712 /* Append one space to the glyph row of iterator IT if doing a
12713 window-based redisplay. DEFAULT_FACE_P non-zero means let the
12714 space have the default face, otherwise let it have the same face as
12715 IT->face_id. Value is non-zero if a space was added.
12717 This function is called to make sure that there is always one glyph
12718 at the end of a glyph row that the cursor can be set on under
12719 window-systems. (If there weren't such a glyph we would not know
12720 how wide and tall a box cursor should be displayed).
12722 At the same time this space let's a nicely handle clearing to the
12723 end of the line if the row ends in italic text. */
12726 append_space (it
, default_face_p
)
12728 int default_face_p
;
12730 if (FRAME_WINDOW_P (it
->f
))
12732 int n
= it
->glyph_row
->used
[TEXT_AREA
];
12734 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
12735 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
12737 /* Save some values that must not be changed.
12738 Must save IT->c and IT->len because otherwise
12739 ITERATOR_AT_END_P wouldn't work anymore after
12740 append_space has been called. */
12741 enum display_element_type saved_what
= it
->what
;
12742 int saved_c
= it
->c
, saved_len
= it
->len
;
12743 int saved_x
= it
->current_x
;
12744 int saved_face_id
= it
->face_id
;
12745 struct text_pos saved_pos
;
12746 Lisp_Object saved_object
;
12749 saved_object
= it
->object
;
12750 saved_pos
= it
->position
;
12752 it
->what
= IT_CHARACTER
;
12753 bzero (&it
->position
, sizeof it
->position
);
12754 it
->object
= make_number (0);
12758 if (default_face_p
)
12759 it
->face_id
= DEFAULT_FACE_ID
;
12760 else if (it
->face_before_selective_p
)
12761 it
->face_id
= it
->saved_face_id
;
12762 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
12763 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0);
12765 PRODUCE_GLYPHS (it
);
12767 it
->current_x
= saved_x
;
12768 it
->object
= saved_object
;
12769 it
->position
= saved_pos
;
12770 it
->what
= saved_what
;
12771 it
->face_id
= saved_face_id
;
12772 it
->len
= saved_len
;
12782 /* Extend the face of the last glyph in the text area of IT->glyph_row
12783 to the end of the display line. Called from display_line.
12784 If the glyph row is empty, add a space glyph to it so that we
12785 know the face to draw. Set the glyph row flag fill_line_p. */
12788 extend_face_to_end_of_line (it
)
12792 struct frame
*f
= it
->f
;
12794 /* If line is already filled, do nothing. */
12795 if (it
->current_x
>= it
->last_visible_x
)
12798 /* Face extension extends the background and box of IT->face_id
12799 to the end of the line. If the background equals the background
12800 of the frame, we don't have to do anything. */
12801 if (it
->face_before_selective_p
)
12802 face
= FACE_FROM_ID (it
->f
, it
->saved_face_id
);
12804 face
= FACE_FROM_ID (f
, it
->face_id
);
12806 if (FRAME_WINDOW_P (f
)
12807 && face
->box
== FACE_NO_BOX
12808 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
12812 /* Set the glyph row flag indicating that the face of the last glyph
12813 in the text area has to be drawn to the end of the text area. */
12814 it
->glyph_row
->fill_line_p
= 1;
12816 /* If current character of IT is not ASCII, make sure we have the
12817 ASCII face. This will be automatically undone the next time
12818 get_next_display_element returns a multibyte character. Note
12819 that the character will always be single byte in unibyte text. */
12820 if (!SINGLE_BYTE_CHAR_P (it
->c
))
12822 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0);
12825 if (FRAME_WINDOW_P (f
))
12827 /* If the row is empty, add a space with the current face of IT,
12828 so that we know which face to draw. */
12829 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
12831 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
12832 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= it
->face_id
;
12833 it
->glyph_row
->used
[TEXT_AREA
] = 1;
12838 /* Save some values that must not be changed. */
12839 int saved_x
= it
->current_x
;
12840 struct text_pos saved_pos
;
12841 Lisp_Object saved_object
;
12842 enum display_element_type saved_what
= it
->what
;
12843 int saved_face_id
= it
->face_id
;
12845 saved_object
= it
->object
;
12846 saved_pos
= it
->position
;
12848 it
->what
= IT_CHARACTER
;
12849 bzero (&it
->position
, sizeof it
->position
);
12850 it
->object
= make_number (0);
12853 it
->face_id
= face
->id
;
12855 PRODUCE_GLYPHS (it
);
12857 while (it
->current_x
<= it
->last_visible_x
)
12858 PRODUCE_GLYPHS (it
);
12860 /* Don't count these blanks really. It would let us insert a left
12861 truncation glyph below and make us set the cursor on them, maybe. */
12862 it
->current_x
= saved_x
;
12863 it
->object
= saved_object
;
12864 it
->position
= saved_pos
;
12865 it
->what
= saved_what
;
12866 it
->face_id
= saved_face_id
;
12871 /* Value is non-zero if text starting at CHARPOS in current_buffer is
12872 trailing whitespace. */
12875 trailing_whitespace_p (charpos
)
12878 int bytepos
= CHAR_TO_BYTE (charpos
);
12881 while (bytepos
< ZV_BYTE
12882 && (c
= FETCH_CHAR (bytepos
),
12883 c
== ' ' || c
== '\t'))
12886 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
12888 if (bytepos
!= PT_BYTE
)
12895 /* Highlight trailing whitespace, if any, in ROW. */
12898 highlight_trailing_whitespace (f
, row
)
12900 struct glyph_row
*row
;
12902 int used
= row
->used
[TEXT_AREA
];
12906 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
12907 struct glyph
*glyph
= start
+ used
- 1;
12909 /* Skip over glyphs inserted to display the cursor at the
12910 end of a line, for extending the face of the last glyph
12911 to the end of the line on terminals, and for truncation
12912 and continuation glyphs. */
12913 while (glyph
>= start
12914 && glyph
->type
== CHAR_GLYPH
12915 && INTEGERP (glyph
->object
))
12918 /* If last glyph is a space or stretch, and it's trailing
12919 whitespace, set the face of all trailing whitespace glyphs in
12920 IT->glyph_row to `trailing-whitespace'. */
12922 && BUFFERP (glyph
->object
)
12923 && (glyph
->type
== STRETCH_GLYPH
12924 || (glyph
->type
== CHAR_GLYPH
12925 && glyph
->u
.ch
== ' '))
12926 && trailing_whitespace_p (glyph
->charpos
))
12928 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
12930 while (glyph
>= start
12931 && BUFFERP (glyph
->object
)
12932 && (glyph
->type
== STRETCH_GLYPH
12933 || (glyph
->type
== CHAR_GLYPH
12934 && glyph
->u
.ch
== ' ')))
12935 (glyph
--)->face_id
= face_id
;
12941 /* Value is non-zero if glyph row ROW in window W should be
12942 used to hold the cursor. */
12945 cursor_row_p (w
, row
)
12947 struct glyph_row
*row
;
12949 int cursor_row_p
= 1;
12951 if (PT
== MATRIX_ROW_END_CHARPOS (row
))
12953 /* If the row ends with a newline from a string, we don't want
12954 the cursor there (if the row is continued it doesn't end in a
12956 if (CHARPOS (row
->end
.string_pos
) >= 0
12957 || MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
12958 cursor_row_p
= row
->continued_p
;
12960 /* If the row ends at ZV, display the cursor at the end of that
12961 row instead of at the start of the row below. */
12962 else if (row
->ends_at_zv_p
)
12968 return cursor_row_p
;
12972 /* Construct the glyph row IT->glyph_row in the desired matrix of
12973 IT->w from text at the current position of IT. See dispextern.h
12974 for an overview of struct it. Value is non-zero if
12975 IT->glyph_row displays text, as opposed to a line displaying ZV
12982 struct glyph_row
*row
= it
->glyph_row
;
12984 /* We always start displaying at hpos zero even if hscrolled. */
12985 xassert (it
->hpos
== 0 && it
->current_x
== 0);
12987 /* We must not display in a row that's not a text row. */
12988 xassert (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
12989 < it
->w
->desired_matrix
->nrows
);
12991 /* Is IT->w showing the region? */
12992 it
->w
->region_showing
= it
->region_beg_charpos
> 0 ? Qt
: Qnil
;
12994 /* Clear the result glyph row and enable it. */
12995 prepare_desired_row (row
);
12997 row
->y
= it
->current_y
;
12998 row
->start
= it
->current
;
12999 row
->continuation_lines_width
= it
->continuation_lines_width
;
13000 row
->displays_text_p
= 1;
13001 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
13002 it
->starts_in_middle_of_char_p
= 0;
13004 /* Arrange the overlays nicely for our purposes. Usually, we call
13005 display_line on only one line at a time, in which case this
13006 can't really hurt too much, or we call it on lines which appear
13007 one after another in the buffer, in which case all calls to
13008 recenter_overlay_lists but the first will be pretty cheap. */
13009 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
13011 /* Move over display elements that are not visible because we are
13012 hscrolled. This may stop at an x-position < IT->first_visible_x
13013 if the first glyph is partially visible or if we hit a line end. */
13014 if (it
->current_x
< it
->first_visible_x
)
13015 move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
13016 MOVE_TO_POS
| MOVE_TO_X
);
13018 /* Get the initial row height. This is either the height of the
13019 text hscrolled, if there is any, or zero. */
13020 row
->ascent
= it
->max_ascent
;
13021 row
->height
= it
->max_ascent
+ it
->max_descent
;
13022 row
->phys_ascent
= it
->max_phys_ascent
;
13023 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
13025 /* Loop generating characters. The loop is left with IT on the next
13026 character to display. */
13029 int n_glyphs_before
, hpos_before
, x_before
;
13031 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
13033 /* Retrieve the next thing to display. Value is zero if end of
13035 if (!get_next_display_element (it
))
13037 /* Maybe add a space at the end of this line that is used to
13038 display the cursor there under X. Set the charpos of the
13039 first glyph of blank lines not corresponding to any text
13041 if ((append_space (it
, 1) && row
->used
[TEXT_AREA
] == 1)
13042 || row
->used
[TEXT_AREA
] == 0)
13044 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
13045 row
->displays_text_p
= 0;
13047 if (!NILP (XBUFFER (it
->w
->buffer
)->indicate_empty_lines
)
13048 && (!MINI_WINDOW_P (it
->w
)
13049 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
13050 row
->indicate_empty_line_p
= 1;
13053 it
->continuation_lines_width
= 0;
13054 row
->ends_at_zv_p
= 1;
13058 /* Now, get the metrics of what we want to display. This also
13059 generates glyphs in `row' (which is IT->glyph_row). */
13060 n_glyphs_before
= row
->used
[TEXT_AREA
];
13063 /* Remember the line height so far in case the next element doesn't
13064 fit on the line. */
13065 if (!it
->truncate_lines_p
)
13067 ascent
= it
->max_ascent
;
13068 descent
= it
->max_descent
;
13069 phys_ascent
= it
->max_phys_ascent
;
13070 phys_descent
= it
->max_phys_descent
;
13073 PRODUCE_GLYPHS (it
);
13075 /* If this display element was in marginal areas, continue with
13077 if (it
->area
!= TEXT_AREA
)
13079 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
13080 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
13081 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
13082 row
->phys_height
= max (row
->phys_height
,
13083 it
->max_phys_ascent
+ it
->max_phys_descent
);
13084 set_iterator_to_next (it
, 1);
13088 /* Does the display element fit on the line? If we truncate
13089 lines, we should draw past the right edge of the window. If
13090 we don't truncate, we want to stop so that we can display the
13091 continuation glyph before the right margin. If lines are
13092 continued, there are two possible strategies for characters
13093 resulting in more than 1 glyph (e.g. tabs): Display as many
13094 glyphs as possible in this line and leave the rest for the
13095 continuation line, or display the whole element in the next
13096 line. Original redisplay did the former, so we do it also. */
13097 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
13098 hpos_before
= it
->hpos
;
13101 if (/* Not a newline. */
13103 /* Glyphs produced fit entirely in the line. */
13104 && it
->current_x
< it
->last_visible_x
)
13106 it
->hpos
+= nglyphs
;
13107 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
13108 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
13109 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
13110 row
->phys_height
= max (row
->phys_height
,
13111 it
->max_phys_ascent
+ it
->max_phys_descent
);
13112 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
13113 row
->x
= x
- it
->first_visible_x
;
13118 struct glyph
*glyph
;
13120 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
13122 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
13123 new_x
= x
+ glyph
->pixel_width
;
13125 if (/* Lines are continued. */
13126 !it
->truncate_lines_p
13127 && (/* Glyph doesn't fit on the line. */
13128 new_x
> it
->last_visible_x
13129 /* Or it fits exactly on a window system frame. */
13130 || (new_x
== it
->last_visible_x
13131 && FRAME_WINDOW_P (it
->f
))))
13133 /* End of a continued line. */
13136 || (new_x
== it
->last_visible_x
13137 && FRAME_WINDOW_P (it
->f
)))
13139 /* Current glyph is the only one on the line or
13140 fits exactly on the line. We must continue
13141 the line because we can't draw the cursor
13142 after the glyph. */
13143 row
->continued_p
= 1;
13144 it
->current_x
= new_x
;
13145 it
->continuation_lines_width
+= new_x
;
13147 if (i
== nglyphs
- 1)
13148 set_iterator_to_next (it
, 1);
13150 else if (CHAR_GLYPH_PADDING_P (*glyph
)
13151 && !FRAME_WINDOW_P (it
->f
))
13153 /* A padding glyph that doesn't fit on this line.
13154 This means the whole character doesn't fit
13156 row
->used
[TEXT_AREA
] = n_glyphs_before
;
13158 /* Fill the rest of the row with continuation
13159 glyphs like in 20.x. */
13160 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
13161 < row
->glyphs
[1 + TEXT_AREA
])
13162 produce_special_glyphs (it
, IT_CONTINUATION
);
13164 row
->continued_p
= 1;
13165 it
->current_x
= x_before
;
13166 it
->continuation_lines_width
+= x_before
;
13168 /* Restore the height to what it was before the
13169 element not fitting on the line. */
13170 it
->max_ascent
= ascent
;
13171 it
->max_descent
= descent
;
13172 it
->max_phys_ascent
= phys_ascent
;
13173 it
->max_phys_descent
= phys_descent
;
13175 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
13177 /* A TAB that extends past the right edge of the
13178 window. This produces a single glyph on
13179 window system frames. We leave the glyph in
13180 this row and let it fill the row, but don't
13181 consume the TAB. */
13182 it
->continuation_lines_width
+= it
->last_visible_x
;
13183 row
->ends_in_middle_of_char_p
= 1;
13184 row
->continued_p
= 1;
13185 glyph
->pixel_width
= it
->last_visible_x
- x
;
13186 it
->starts_in_middle_of_char_p
= 1;
13190 /* Something other than a TAB that draws past
13191 the right edge of the window. Restore
13192 positions to values before the element. */
13193 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
13195 /* Display continuation glyphs. */
13196 if (!FRAME_WINDOW_P (it
->f
))
13197 produce_special_glyphs (it
, IT_CONTINUATION
);
13198 row
->continued_p
= 1;
13200 it
->continuation_lines_width
+= x
;
13202 if (nglyphs
> 1 && i
> 0)
13204 row
->ends_in_middle_of_char_p
= 1;
13205 it
->starts_in_middle_of_char_p
= 1;
13208 /* Restore the height to what it was before the
13209 element not fitting on the line. */
13210 it
->max_ascent
= ascent
;
13211 it
->max_descent
= descent
;
13212 it
->max_phys_ascent
= phys_ascent
;
13213 it
->max_phys_descent
= phys_descent
;
13218 else if (new_x
> it
->first_visible_x
)
13220 /* Increment number of glyphs actually displayed. */
13223 if (x
< it
->first_visible_x
)
13224 /* Glyph is partially visible, i.e. row starts at
13225 negative X position. */
13226 row
->x
= x
- it
->first_visible_x
;
13230 /* Glyph is completely off the left margin of the
13231 window. This should not happen because of the
13232 move_it_in_display_line at the start of this
13233 function, unless the text display area of the
13234 window is empty. */
13235 xassert (it
->first_visible_x
<= it
->last_visible_x
);
13239 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
13240 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
13241 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
13242 row
->phys_height
= max (row
->phys_height
,
13243 it
->max_phys_ascent
+ it
->max_phys_descent
);
13245 /* End of this display line if row is continued. */
13246 if (row
->continued_p
)
13250 /* Is this a line end? If yes, we're also done, after making
13251 sure that a non-default face is extended up to the right
13252 margin of the window. */
13253 if (ITERATOR_AT_END_OF_LINE_P (it
))
13255 int used_before
= row
->used
[TEXT_AREA
];
13257 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
13259 /* Add a space at the end of the line that is used to
13260 display the cursor there. */
13261 append_space (it
, 0);
13263 /* Extend the face to the end of the line. */
13264 extend_face_to_end_of_line (it
);
13266 /* Make sure we have the position. */
13267 if (used_before
== 0)
13268 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
13270 /* Consume the line end. This skips over invisible lines. */
13271 set_iterator_to_next (it
, 1);
13272 it
->continuation_lines_width
= 0;
13276 /* Proceed with next display element. Note that this skips
13277 over lines invisible because of selective display. */
13278 set_iterator_to_next (it
, 1);
13280 /* If we truncate lines, we are done when the last displayed
13281 glyphs reach past the right margin of the window. */
13282 if (it
->truncate_lines_p
13283 && (FRAME_WINDOW_P (it
->f
)
13284 ? (it
->current_x
>= it
->last_visible_x
)
13285 : (it
->current_x
> it
->last_visible_x
)))
13287 /* Maybe add truncation glyphs. */
13288 if (!FRAME_WINDOW_P (it
->f
))
13292 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
13293 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
13296 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
13298 row
->used
[TEXT_AREA
] = i
;
13299 produce_special_glyphs (it
, IT_TRUNCATION
);
13303 row
->truncated_on_right_p
= 1;
13304 it
->continuation_lines_width
= 0;
13305 reseat_at_next_visible_line_start (it
, 0);
13306 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
13307 it
->hpos
= hpos_before
;
13308 it
->current_x
= x_before
;
13313 /* If line is not empty and hscrolled, maybe insert truncation glyphs
13314 at the left window margin. */
13315 if (it
->first_visible_x
13316 && IT_CHARPOS (*it
) != MATRIX_ROW_START_CHARPOS (row
))
13318 if (!FRAME_WINDOW_P (it
->f
))
13319 insert_left_trunc_glyphs (it
);
13320 row
->truncated_on_left_p
= 1;
13323 /* If the start of this line is the overlay arrow-position, then
13324 mark this glyph row as the one containing the overlay arrow.
13325 This is clearly a mess with variable size fonts. It would be
13326 better to let it be displayed like cursors under X. */
13327 if (MARKERP (Voverlay_arrow_position
)
13328 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
13329 && (MATRIX_ROW_START_CHARPOS (row
)
13330 == marker_position (Voverlay_arrow_position
))
13331 && STRINGP (Voverlay_arrow_string
)
13332 && ! overlay_arrow_seen
)
13334 /* Overlay arrow in window redisplay is a fringe bitmap. */
13335 if (!FRAME_WINDOW_P (it
->f
))
13337 struct glyph_row
*arrow_row
= get_overlay_arrow_glyph_row (it
->w
);
13338 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
13339 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
13340 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
13341 struct glyph
*p2
, *end
;
13343 /* Copy the arrow glyphs. */
13344 while (glyph
< arrow_end
)
13347 /* Throw away padding glyphs. */
13349 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
13350 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
13356 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
13360 overlay_arrow_seen
= 1;
13361 row
->overlay_arrow_p
= 1;
13364 /* Compute pixel dimensions of this line. */
13365 compute_line_metrics (it
);
13367 /* Remember the position at which this line ends. */
13368 row
->end
= it
->current
;
13370 /* Maybe set the cursor. */
13371 if (it
->w
->cursor
.vpos
< 0
13372 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
13373 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
13374 && cursor_row_p (it
->w
, row
))
13375 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
13377 /* Highlight trailing whitespace. */
13378 if (!NILP (Vshow_trailing_whitespace
))
13379 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
13381 /* Prepare for the next line. This line starts horizontally at (X
13382 HPOS) = (0 0). Vertical positions are incremented. As a
13383 convenience for the caller, IT->glyph_row is set to the next
13385 it
->current_x
= it
->hpos
= 0;
13386 it
->current_y
+= row
->height
;
13389 return row
->displays_text_p
;
13394 /***********************************************************************
13396 ***********************************************************************/
13398 /* Redisplay the menu bar in the frame for window W.
13400 The menu bar of X frames that don't have X toolkit support is
13401 displayed in a special window W->frame->menu_bar_window.
13403 The menu bar of terminal frames is treated specially as far as
13404 glyph matrices are concerned. Menu bar lines are not part of
13405 windows, so the update is done directly on the frame matrix rows
13406 for the menu bar. */
13409 display_menu_bar (w
)
13412 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
13417 /* Don't do all this for graphical frames. */
13419 if (!NILP (Vwindow_system
))
13422 #ifdef USE_X_TOOLKIT
13427 if (FRAME_MAC_P (f
))
13431 #ifdef USE_X_TOOLKIT
13432 xassert (!FRAME_WINDOW_P (f
));
13433 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
13434 it
.first_visible_x
= 0;
13435 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
13436 #else /* not USE_X_TOOLKIT */
13437 if (FRAME_WINDOW_P (f
))
13439 /* Menu bar lines are displayed in the desired matrix of the
13440 dummy window menu_bar_window. */
13441 struct window
*menu_w
;
13442 xassert (WINDOWP (f
->menu_bar_window
));
13443 menu_w
= XWINDOW (f
->menu_bar_window
);
13444 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
13446 it
.first_visible_x
= 0;
13447 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
13451 /* This is a TTY frame, i.e. character hpos/vpos are used as
13453 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
13455 it
.first_visible_x
= 0;
13456 it
.last_visible_x
= FRAME_WIDTH (f
);
13458 #endif /* not USE_X_TOOLKIT */
13460 if (! mode_line_inverse_video
)
13461 /* Force the menu-bar to be displayed in the default face. */
13462 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
13464 /* Clear all rows of the menu bar. */
13465 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
13467 struct glyph_row
*row
= it
.glyph_row
+ i
;
13468 clear_glyph_row (row
);
13469 row
->enabled_p
= 1;
13470 row
->full_width_p
= 1;
13473 /* Display all items of the menu bar. */
13474 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
13475 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
13477 Lisp_Object string
;
13479 /* Stop at nil string. */
13480 string
= AREF (items
, i
+ 1);
13484 /* Remember where item was displayed. */
13485 AREF (items
, i
+ 3) = make_number (it
.hpos
);
13487 /* Display the item, pad with one space. */
13488 if (it
.current_x
< it
.last_visible_x
)
13489 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
13490 SCHARS (string
) + 1, 0, 0, -1);
13493 /* Fill out the line with spaces. */
13494 if (it
.current_x
< it
.last_visible_x
)
13495 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
13497 /* Compute the total height of the lines. */
13498 compute_line_metrics (&it
);
13503 /***********************************************************************
13505 ***********************************************************************/
13507 /* Redisplay mode lines in the window tree whose root is WINDOW. If
13508 FORCE is non-zero, redisplay mode lines unconditionally.
13509 Otherwise, redisplay only mode lines that are garbaged. Value is
13510 the number of windows whose mode lines were redisplayed. */
13513 redisplay_mode_lines (window
, force
)
13514 Lisp_Object window
;
13519 while (!NILP (window
))
13521 struct window
*w
= XWINDOW (window
);
13523 if (WINDOWP (w
->hchild
))
13524 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
13525 else if (WINDOWP (w
->vchild
))
13526 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
13528 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
13529 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
13531 struct text_pos lpoint
;
13532 struct buffer
*old
= current_buffer
;
13534 /* Set the window's buffer for the mode line display. */
13535 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
13536 set_buffer_internal_1 (XBUFFER (w
->buffer
));
13538 /* Point refers normally to the selected window. For any
13539 other window, set up appropriate value. */
13540 if (!EQ (window
, selected_window
))
13542 struct text_pos pt
;
13544 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
13545 if (CHARPOS (pt
) < BEGV
)
13546 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
13547 else if (CHARPOS (pt
) > (ZV
- 1))
13548 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
13550 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
13553 /* Display mode lines. */
13554 clear_glyph_matrix (w
->desired_matrix
);
13555 if (display_mode_lines (w
))
13558 w
->must_be_updated_p
= 1;
13561 /* Restore old settings. */
13562 set_buffer_internal_1 (old
);
13563 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
13573 /* Display the mode and/or top line of window W. Value is the number
13574 of mode lines displayed. */
13577 display_mode_lines (w
)
13580 Lisp_Object old_selected_window
, old_selected_frame
;
13583 old_selected_frame
= selected_frame
;
13584 selected_frame
= w
->frame
;
13585 old_selected_window
= selected_window
;
13586 XSETWINDOW (selected_window
, w
);
13588 /* These will be set while the mode line specs are processed. */
13589 line_number_displayed
= 0;
13590 w
->column_number_displayed
= Qnil
;
13592 if (WINDOW_WANTS_MODELINE_P (w
))
13594 struct window
*sel_w
= XWINDOW (old_selected_window
);
13596 /* Select mode line face based on the real selected window. */
13597 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
13598 current_buffer
->mode_line_format
);
13602 if (WINDOW_WANTS_HEADER_LINE_P (w
))
13604 display_mode_line (w
, HEADER_LINE_FACE_ID
,
13605 current_buffer
->header_line_format
);
13609 selected_frame
= old_selected_frame
;
13610 selected_window
= old_selected_window
;
13615 /* Display mode or top line of window W. FACE_ID specifies which line
13616 to display; it is either MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID.
13617 FORMAT is the mode line format to display. Value is the pixel
13618 height of the mode line displayed. */
13621 display_mode_line (w
, face_id
, format
)
13623 enum face_id face_id
;
13624 Lisp_Object format
;
13629 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
13630 prepare_desired_row (it
.glyph_row
);
13632 if (! mode_line_inverse_video
)
13633 /* Force the mode-line to be displayed in the default face. */
13634 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
13636 /* Temporarily make frame's keyboard the current kboard so that
13637 kboard-local variables in the mode_line_format will get the right
13639 push_frame_kboard (it
.f
);
13640 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
13641 pop_frame_kboard ();
13643 /* Fill up with spaces. */
13644 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
13646 compute_line_metrics (&it
);
13647 it
.glyph_row
->full_width_p
= 1;
13648 it
.glyph_row
->mode_line_p
= 1;
13649 it
.glyph_row
->continued_p
= 0;
13650 it
.glyph_row
->truncated_on_left_p
= 0;
13651 it
.glyph_row
->truncated_on_right_p
= 0;
13653 /* Make a 3D mode-line have a shadow at its right end. */
13654 face
= FACE_FROM_ID (it
.f
, face_id
);
13655 extend_face_to_end_of_line (&it
);
13656 if (face
->box
!= FACE_NO_BOX
)
13658 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
13659 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
13660 last
->right_box_line_p
= 1;
13663 return it
.glyph_row
->height
;
13666 /* Alist that caches the results of :propertize.
13667 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
13668 Lisp_Object mode_line_proptrans_alist
;
13670 /* List of strings making up the mode-line. */
13671 Lisp_Object mode_line_string_list
;
13673 /* Base face property when building propertized mode line string. */
13674 static Lisp_Object mode_line_string_face
;
13675 static Lisp_Object mode_line_string_face_prop
;
13678 /* Contribute ELT to the mode line for window IT->w. How it
13679 translates into text depends on its data type.
13681 IT describes the display environment in which we display, as usual.
13683 DEPTH is the depth in recursion. It is used to prevent
13684 infinite recursion here.
13686 FIELD_WIDTH is the number of characters the display of ELT should
13687 occupy in the mode line, and PRECISION is the maximum number of
13688 characters to display from ELT's representation. See
13689 display_string for details.
13691 Returns the hpos of the end of the text generated by ELT.
13693 PROPS is a property list to add to any string we encounter.
13695 If RISKY is nonzero, remove (disregard) any properties in any string
13696 we encounter, and ignore :eval and :propertize.
13698 If the global variable `frame_title_ptr' is non-NULL, then the output
13699 is passed to `store_frame_title' instead of `display_string'. */
13702 display_mode_element (it
, depth
, field_width
, precision
, elt
, props
, risky
)
13705 int field_width
, precision
;
13706 Lisp_Object elt
, props
;
13709 int n
= 0, field
, prec
;
13718 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
13722 /* A string: output it and check for %-constructs within it. */
13724 const unsigned char *this, *lisp_string
;
13726 if (!NILP (props
) || risky
)
13728 Lisp_Object oprops
, aelt
;
13729 oprops
= Ftext_properties_at (make_number (0), elt
);
13731 if (NILP (Fequal (props
, oprops
)) || risky
)
13733 /* If the starting string has properties,
13734 merge the specified ones onto the existing ones. */
13735 if (! NILP (oprops
) && !risky
)
13739 oprops
= Fcopy_sequence (oprops
);
13741 while (CONSP (tem
))
13743 oprops
= Fplist_put (oprops
, XCAR (tem
),
13744 XCAR (XCDR (tem
)));
13745 tem
= XCDR (XCDR (tem
));
13750 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
13751 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
13753 mode_line_proptrans_alist
13754 = Fcons (aelt
, Fdelq (aelt
, mode_line_proptrans_alist
));
13761 elt
= Fcopy_sequence (elt
);
13762 Fset_text_properties (make_number (0), Flength (elt
),
13764 /* Add this item to mode_line_proptrans_alist. */
13765 mode_line_proptrans_alist
13766 = Fcons (Fcons (elt
, props
),
13767 mode_line_proptrans_alist
);
13768 /* Truncate mode_line_proptrans_alist
13769 to at most 50 elements. */
13770 tem
= Fnthcdr (make_number (50),
13771 mode_line_proptrans_alist
);
13773 XSETCDR (tem
, Qnil
);
13778 this = SDATA (elt
);
13779 lisp_string
= this;
13783 prec
= precision
- n
;
13784 if (frame_title_ptr
)
13785 n
+= store_frame_title (SDATA (elt
), -1, prec
);
13786 else if (!NILP (mode_line_string_list
))
13787 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
13789 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
13790 0, prec
, 0, STRING_MULTIBYTE (elt
));
13795 while ((precision
<= 0 || n
< precision
)
13797 && (frame_title_ptr
13798 || !NILP (mode_line_string_list
)
13799 || it
->current_x
< it
->last_visible_x
))
13801 const unsigned char *last
= this;
13803 /* Advance to end of string or next format specifier. */
13804 while ((c
= *this++) != '\0' && c
!= '%')
13807 if (this - 1 != last
)
13809 /* Output to end of string or up to '%'. Field width
13810 is length of string. Don't output more than
13811 PRECISION allows us. */
13814 prec
= chars_in_text (last
, this - last
);
13815 if (precision
> 0 && prec
> precision
- n
)
13816 prec
= precision
- n
;
13818 if (frame_title_ptr
)
13819 n
+= store_frame_title (last
, 0, prec
);
13820 else if (!NILP (mode_line_string_list
))
13822 int bytepos
= last
- lisp_string
;
13823 int charpos
= string_byte_to_char (elt
, bytepos
);
13824 n
+= store_mode_line_string (NULL
,
13825 Fsubstring (elt
, make_number (charpos
),
13826 make_number (charpos
+ prec
)),
13831 int bytepos
= last
- lisp_string
;
13832 int charpos
= string_byte_to_char (elt
, bytepos
);
13833 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
13835 STRING_MULTIBYTE (elt
));
13838 else /* c == '%' */
13840 const unsigned char *percent_position
= this;
13842 /* Get the specified minimum width. Zero means
13845 while ((c
= *this++) >= '0' && c
<= '9')
13846 field
= field
* 10 + c
- '0';
13848 /* Don't pad beyond the total padding allowed. */
13849 if (field_width
- n
> 0 && field
> field_width
- n
)
13850 field
= field_width
- n
;
13852 /* Note that either PRECISION <= 0 or N < PRECISION. */
13853 prec
= precision
- n
;
13856 n
+= display_mode_element (it
, depth
, field
, prec
,
13857 Vglobal_mode_string
, props
,
13862 int bytepos
, charpos
;
13863 unsigned char *spec
;
13865 bytepos
= percent_position
- lisp_string
;
13866 charpos
= (STRING_MULTIBYTE (elt
)
13867 ? string_byte_to_char (elt
, bytepos
)
13871 = decode_mode_spec (it
->w
, c
, field
, prec
, &multibyte
);
13873 if (frame_title_ptr
)
13874 n
+= store_frame_title (spec
, field
, prec
);
13875 else if (!NILP (mode_line_string_list
))
13877 int len
= strlen (spec
);
13878 Lisp_Object tem
= make_string (spec
, len
);
13879 props
= Ftext_properties_at (make_number (charpos
), elt
);
13880 /* Should only keep face property in props */
13881 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
13885 int nglyphs_before
, nwritten
;
13887 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
13888 nwritten
= display_string (spec
, Qnil
, elt
,
13893 /* Assign to the glyphs written above the
13894 string where the `%x' came from, position
13898 struct glyph
*glyph
13899 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
13903 for (i
= 0; i
< nwritten
; ++i
)
13905 glyph
[i
].object
= elt
;
13906 glyph
[i
].charpos
= charpos
;
13921 /* A symbol: process the value of the symbol recursively
13922 as if it appeared here directly. Avoid error if symbol void.
13923 Special case: if value of symbol is a string, output the string
13926 register Lisp_Object tem
;
13928 /* If the variable is not marked as risky to set
13929 then its contents are risky to use. */
13930 if (NILP (Fget (elt
, Qrisky_local_variable
)))
13933 tem
= Fboundp (elt
);
13936 tem
= Fsymbol_value (elt
);
13937 /* If value is a string, output that string literally:
13938 don't check for % within it. */
13942 if (!EQ (tem
, elt
))
13944 /* Give up right away for nil or t. */
13954 register Lisp_Object car
, tem
;
13956 /* A cons cell: five distinct cases.
13957 If first element is :eval or :propertize, do something special.
13958 If first element is a string or a cons, process all the elements
13959 and effectively concatenate them.
13960 If first element is a negative number, truncate displaying cdr to
13961 at most that many characters. If positive, pad (with spaces)
13962 to at least that many characters.
13963 If first element is a symbol, process the cadr or caddr recursively
13964 according to whether the symbol's value is non-nil or nil. */
13966 if (EQ (car
, QCeval
))
13968 /* An element of the form (:eval FORM) means evaluate FORM
13969 and use the result as mode line elements. */
13974 if (CONSP (XCDR (elt
)))
13977 spec
= safe_eval (XCAR (XCDR (elt
)));
13978 n
+= display_mode_element (it
, depth
, field_width
- n
,
13979 precision
- n
, spec
, props
,
13983 else if (EQ (car
, QCpropertize
))
13985 /* An element of the form (:propertize ELT PROPS...)
13986 means display ELT but applying properties PROPS. */
13991 if (CONSP (XCDR (elt
)))
13992 n
+= display_mode_element (it
, depth
, field_width
- n
,
13993 precision
- n
, XCAR (XCDR (elt
)),
13994 XCDR (XCDR (elt
)), risky
);
13996 else if (SYMBOLP (car
))
13998 tem
= Fboundp (car
);
14002 /* elt is now the cdr, and we know it is a cons cell.
14003 Use its car if CAR has a non-nil value. */
14006 tem
= Fsymbol_value (car
);
14013 /* Symbol's value is nil (or symbol is unbound)
14014 Get the cddr of the original list
14015 and if possible find the caddr and use that. */
14019 else if (!CONSP (elt
))
14024 else if (INTEGERP (car
))
14026 register int lim
= XINT (car
);
14030 /* Negative int means reduce maximum width. */
14031 if (precision
<= 0)
14034 precision
= min (precision
, -lim
);
14038 /* Padding specified. Don't let it be more than
14039 current maximum. */
14041 lim
= min (precision
, lim
);
14043 /* If that's more padding than already wanted, queue it.
14044 But don't reduce padding already specified even if
14045 that is beyond the current truncation point. */
14046 field_width
= max (lim
, field_width
);
14050 else if (STRINGP (car
) || CONSP (car
))
14052 register int limit
= 50;
14053 /* Limit is to protect against circular lists. */
14056 && (precision
<= 0 || n
< precision
))
14058 n
+= display_mode_element (it
, depth
, field_width
- n
,
14059 precision
- n
, XCAR (elt
),
14069 if (frame_title_ptr
)
14070 n
+= store_frame_title ("*invalid*", 0, precision
- n
);
14071 else if (!NILP (mode_line_string_list
))
14072 n
+= store_mode_line_string ("*invalid*", Qnil
, 0, 0, precision
- n
, Qnil
);
14074 n
+= display_string ("*invalid*", Qnil
, Qnil
, 0, 0, it
, 0,
14075 precision
- n
, 0, 0);
14079 /* Pad to FIELD_WIDTH. */
14080 if (field_width
> 0 && n
< field_width
)
14082 if (frame_title_ptr
)
14083 n
+= store_frame_title ("", field_width
- n
, 0);
14084 else if (!NILP (mode_line_string_list
))
14085 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
14087 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
14094 /* Store a mode-line string element in mode_line_string_list.
14096 If STRING is non-null, display that C string. Otherwise, the Lisp
14097 string LISP_STRING is displayed.
14099 FIELD_WIDTH is the minimum number of output glyphs to produce.
14100 If STRING has fewer characters than FIELD_WIDTH, pad to the right
14101 with spaces. FIELD_WIDTH <= 0 means don't pad.
14103 PRECISION is the maximum number of characters to output from
14104 STRING. PRECISION <= 0 means don't truncate the string.
14106 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
14107 properties to the string.
14109 PROPS are the properties to add to the string.
14110 The mode_line_string_face face property is always added to the string.
14113 static int store_mode_line_string (string
, lisp_string
, copy_string
, field_width
, precision
, props
)
14115 Lisp_Object lisp_string
;
14124 if (string
!= NULL
)
14126 len
= strlen (string
);
14127 if (precision
> 0 && len
> precision
)
14129 lisp_string
= make_string (string
, len
);
14131 props
= mode_line_string_face_prop
;
14132 else if (!NILP (mode_line_string_face
))
14134 Lisp_Object face
= Fplist_get (props
, Qface
);
14135 props
= Fcopy_sequence (props
);
14137 face
= mode_line_string_face
;
14139 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
14140 props
= Fplist_put (props
, Qface
, face
);
14142 Fadd_text_properties (make_number (0), make_number (len
),
14143 props
, lisp_string
);
14147 len
= XFASTINT (Flength (lisp_string
));
14148 if (precision
> 0 && len
> precision
)
14151 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
14154 if (!NILP (mode_line_string_face
))
14158 props
= Ftext_properties_at (make_number (0), lisp_string
);
14159 face
= Fplist_get (props
, Qface
);
14161 face
= mode_line_string_face
;
14163 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
14164 props
= Fcons (Qface
, Fcons (face
, Qnil
));
14166 lisp_string
= Fcopy_sequence (lisp_string
);
14169 Fadd_text_properties (make_number (0), make_number (len
),
14170 props
, lisp_string
);
14175 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
14179 if (field_width
> len
)
14181 field_width
-= len
;
14182 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
14184 Fadd_text_properties (make_number (0), make_number (field_width
),
14185 props
, lisp_string
);
14186 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
14194 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
14196 doc
: /* Return the mode-line of selected window as a string.
14197 First optional arg FORMAT specifies a different format string (see
14198 `mode-line-format' for details) to use. If FORMAT is t, return
14199 the buffer's header-line. Second optional arg WINDOW specifies a
14200 different window to use as the context for the formatting.
14201 If third optional arg NO-PROPS is non-nil, string is not propertized. */)
14202 (format
, window
, no_props
)
14203 Lisp_Object format
, window
, no_props
;
14208 struct buffer
*old_buffer
= NULL
;
14209 enum face_id face_id
= DEFAULT_FACE_ID
;
14212 window
= selected_window
;
14213 CHECK_WINDOW (window
);
14214 w
= XWINDOW (window
);
14215 CHECK_BUFFER (w
->buffer
);
14217 if (XBUFFER (w
->buffer
) != current_buffer
)
14219 old_buffer
= current_buffer
;
14220 set_buffer_internal_1 (XBUFFER (w
->buffer
));
14223 if (NILP (format
) || EQ (format
, Qt
))
14225 face_id
= NILP (format
)
14226 ? CURRENT_MODE_LINE_FACE_ID (w
) :
14227 HEADER_LINE_FACE_ID
;
14228 format
= NILP (format
)
14229 ? current_buffer
->mode_line_format
14230 : current_buffer
->header_line_format
;
14233 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
14235 if (NILP (no_props
))
14237 mode_line_string_face
=
14238 (face_id
== MODE_LINE_FACE_ID
? Qmode_line
:
14239 face_id
== MODE_LINE_INACTIVE_FACE_ID
? Qmode_line_inactive
:
14240 face_id
== HEADER_LINE_FACE_ID
? Qheader_line
: Qnil
);
14242 mode_line_string_face_prop
=
14243 NILP (mode_line_string_face
) ? Qnil
:
14244 Fcons (Qface
, Fcons (mode_line_string_face
, Qnil
));
14246 /* We need a dummy last element in mode_line_string_list to
14247 indicate we are building the propertized mode-line string.
14248 Using mode_line_string_face_prop here GC protects it. */
14249 mode_line_string_list
=
14250 Fcons (mode_line_string_face_prop
, Qnil
);
14251 frame_title_ptr
= NULL
;
14255 mode_line_string_face_prop
= Qnil
;
14256 mode_line_string_list
= Qnil
;
14257 frame_title_ptr
= frame_title_buf
;
14260 push_frame_kboard (it
.f
);
14261 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
14262 pop_frame_kboard ();
14265 set_buffer_internal_1 (old_buffer
);
14267 if (NILP (no_props
))
14270 mode_line_string_list
= Fnreverse (mode_line_string_list
);
14271 str
= Fmapconcat (intern ("identity"), XCDR (mode_line_string_list
),
14272 make_string ("", 0));
14273 mode_line_string_face_prop
= Qnil
;
14274 mode_line_string_list
= Qnil
;
14278 len
= frame_title_ptr
- frame_title_buf
;
14279 if (len
> 0 && frame_title_ptr
[-1] == '-')
14281 /* Mode lines typically ends with numerous dashes; reduce to two dashes. */
14282 while (frame_title_ptr
> frame_title_buf
&& *--frame_title_ptr
== '-')
14284 frame_title_ptr
+= 3; /* restore last non-dash + two dashes */
14285 if (len
> frame_title_ptr
- frame_title_buf
)
14286 len
= frame_title_ptr
- frame_title_buf
;
14289 frame_title_ptr
= NULL
;
14290 return make_string (frame_title_buf
, len
);
14293 /* Write a null-terminated, right justified decimal representation of
14294 the positive integer D to BUF using a minimal field width WIDTH. */
14297 pint2str (buf
, width
, d
)
14298 register char *buf
;
14299 register int width
;
14302 register char *p
= buf
;
14310 *p
++ = d
% 10 + '0';
14315 for (width
-= (int) (p
- buf
); width
> 0; --width
)
14326 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
14327 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
14328 type of CODING_SYSTEM. Return updated pointer into BUF. */
14330 static unsigned char invalid_eol_type
[] = "(*invalid*)";
14333 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
14334 Lisp_Object coding_system
;
14335 register char *buf
;
14339 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
14340 const unsigned char *eol_str
;
14342 /* The EOL conversion we are using. */
14343 Lisp_Object eoltype
;
14345 val
= Fget (coding_system
, Qcoding_system
);
14348 if (!VECTORP (val
)) /* Not yet decided. */
14353 eoltype
= eol_mnemonic_undecided
;
14354 /* Don't mention EOL conversion if it isn't decided. */
14358 Lisp_Object eolvalue
;
14360 eolvalue
= Fget (coding_system
, Qeol_type
);
14363 *buf
++ = XFASTINT (AREF (val
, 1));
14367 /* The EOL conversion that is normal on this system. */
14369 if (NILP (eolvalue
)) /* Not yet decided. */
14370 eoltype
= eol_mnemonic_undecided
;
14371 else if (VECTORP (eolvalue
)) /* Not yet decided. */
14372 eoltype
= eol_mnemonic_undecided
;
14373 else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
14374 eoltype
= (XFASTINT (eolvalue
) == 0
14375 ? eol_mnemonic_unix
14376 : (XFASTINT (eolvalue
) == 1
14377 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
14383 /* Mention the EOL conversion if it is not the usual one. */
14384 if (STRINGP (eoltype
))
14386 eol_str
= SDATA (eoltype
);
14387 eol_str_len
= SBYTES (eoltype
);
14389 else if (INTEGERP (eoltype
)
14390 && CHAR_VALID_P (XINT (eoltype
), 0))
14392 unsigned char *tmp
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
);
14393 eol_str_len
= CHAR_STRING (XINT (eoltype
), tmp
);
14398 eol_str
= invalid_eol_type
;
14399 eol_str_len
= sizeof (invalid_eol_type
) - 1;
14401 bcopy (eol_str
, buf
, eol_str_len
);
14402 buf
+= eol_str_len
;
14408 /* Return a string for the output of a mode line %-spec for window W,
14409 generated by character C. PRECISION >= 0 means don't return a
14410 string longer than that value. FIELD_WIDTH > 0 means pad the
14411 string returned with spaces to that value. Return 1 in *MULTIBYTE
14412 if the result is multibyte text. */
14414 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
14417 decode_mode_spec (w
, c
, field_width
, precision
, multibyte
)
14420 int field_width
, precision
;
14424 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
14425 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
14426 struct buffer
*b
= XBUFFER (w
->buffer
);
14434 if (!NILP (b
->read_only
))
14436 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
14441 /* This differs from %* only for a modified read-only buffer. */
14442 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
14444 if (!NILP (b
->read_only
))
14449 /* This differs from %* in ignoring read-only-ness. */
14450 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
14462 if (command_loop_level
> 5)
14464 p
= decode_mode_spec_buf
;
14465 for (i
= 0; i
< command_loop_level
; i
++)
14468 return decode_mode_spec_buf
;
14476 if (command_loop_level
> 5)
14478 p
= decode_mode_spec_buf
;
14479 for (i
= 0; i
< command_loop_level
; i
++)
14482 return decode_mode_spec_buf
;
14489 /* Let lots_of_dashes be a string of infinite length. */
14490 if (!NILP (mode_line_string_list
))
14492 if (field_width
<= 0
14493 || field_width
> sizeof (lots_of_dashes
))
14495 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
14496 decode_mode_spec_buf
[i
] = '-';
14497 decode_mode_spec_buf
[i
] = '\0';
14498 return decode_mode_spec_buf
;
14501 return lots_of_dashes
;
14510 int col
= (int) current_column (); /* iftc */
14511 w
->column_number_displayed
= make_number (col
);
14512 pint2str (decode_mode_spec_buf
, field_width
, col
);
14513 return decode_mode_spec_buf
;
14517 /* %F displays the frame name. */
14518 if (!NILP (f
->title
))
14519 return (char *) SDATA (f
->title
);
14520 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
14521 return (char *) SDATA (f
->name
);
14530 int startpos
= XMARKER (w
->start
)->charpos
;
14531 int startpos_byte
= marker_byte_position (w
->start
);
14532 int line
, linepos
, linepos_byte
, topline
;
14534 int height
= XFASTINT (w
->height
);
14536 /* If we decided that this buffer isn't suitable for line numbers,
14537 don't forget that too fast. */
14538 if (EQ (w
->base_line_pos
, w
->buffer
))
14540 /* But do forget it, if the window shows a different buffer now. */
14541 else if (BUFFERP (w
->base_line_pos
))
14542 w
->base_line_pos
= Qnil
;
14544 /* If the buffer is very big, don't waste time. */
14545 if (INTEGERP (Vline_number_display_limit
)
14546 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
14548 w
->base_line_pos
= Qnil
;
14549 w
->base_line_number
= Qnil
;
14553 if (!NILP (w
->base_line_number
)
14554 && !NILP (w
->base_line_pos
)
14555 && XFASTINT (w
->base_line_pos
) <= startpos
)
14557 line
= XFASTINT (w
->base_line_number
);
14558 linepos
= XFASTINT (w
->base_line_pos
);
14559 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
14564 linepos
= BUF_BEGV (b
);
14565 linepos_byte
= BUF_BEGV_BYTE (b
);
14568 /* Count lines from base line to window start position. */
14569 nlines
= display_count_lines (linepos
, linepos_byte
,
14573 topline
= nlines
+ line
;
14575 /* Determine a new base line, if the old one is too close
14576 or too far away, or if we did not have one.
14577 "Too close" means it's plausible a scroll-down would
14578 go back past it. */
14579 if (startpos
== BUF_BEGV (b
))
14581 w
->base_line_number
= make_number (topline
);
14582 w
->base_line_pos
= make_number (BUF_BEGV (b
));
14584 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
14585 || linepos
== BUF_BEGV (b
))
14587 int limit
= BUF_BEGV (b
);
14588 int limit_byte
= BUF_BEGV_BYTE (b
);
14590 int distance
= (height
* 2 + 30) * line_number_display_limit_width
;
14592 if (startpos
- distance
> limit
)
14594 limit
= startpos
- distance
;
14595 limit_byte
= CHAR_TO_BYTE (limit
);
14598 nlines
= display_count_lines (startpos
, startpos_byte
,
14600 - (height
* 2 + 30),
14602 /* If we couldn't find the lines we wanted within
14603 line_number_display_limit_width chars per line,
14604 give up on line numbers for this window. */
14605 if (position
== limit_byte
&& limit
== startpos
- distance
)
14607 w
->base_line_pos
= w
->buffer
;
14608 w
->base_line_number
= Qnil
;
14612 w
->base_line_number
= make_number (topline
- nlines
);
14613 w
->base_line_pos
= make_number (BYTE_TO_CHAR (position
));
14616 /* Now count lines from the start pos to point. */
14617 nlines
= display_count_lines (startpos
, startpos_byte
,
14618 PT_BYTE
, PT
, &junk
);
14620 /* Record that we did display the line number. */
14621 line_number_displayed
= 1;
14623 /* Make the string to show. */
14624 pint2str (decode_mode_spec_buf
, field_width
, topline
+ nlines
);
14625 return decode_mode_spec_buf
;
14628 char* p
= decode_mode_spec_buf
;
14629 int pad
= field_width
- 2;
14635 return decode_mode_spec_buf
;
14641 obj
= b
->mode_name
;
14645 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
14651 int pos
= marker_position (w
->start
);
14652 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
14654 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
14656 if (pos
<= BUF_BEGV (b
))
14661 else if (pos
<= BUF_BEGV (b
))
14665 if (total
> 1000000)
14666 /* Do it differently for a large value, to avoid overflow. */
14667 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
14669 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
14670 /* We can't normally display a 3-digit number,
14671 so get us a 2-digit number that is close. */
14674 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
14675 return decode_mode_spec_buf
;
14679 /* Display percentage of size above the bottom of the screen. */
14682 int toppos
= marker_position (w
->start
);
14683 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
14684 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
14686 if (botpos
>= BUF_ZV (b
))
14688 if (toppos
<= BUF_BEGV (b
))
14695 if (total
> 1000000)
14696 /* Do it differently for a large value, to avoid overflow. */
14697 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
14699 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
14700 /* We can't normally display a 3-digit number,
14701 so get us a 2-digit number that is close. */
14704 if (toppos
<= BUF_BEGV (b
))
14705 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
14707 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
14708 return decode_mode_spec_buf
;
14713 /* status of process */
14714 obj
= Fget_buffer_process (w
->buffer
);
14716 return "no process";
14717 #ifdef subprocesses
14718 obj
= Fsymbol_name (Fprocess_status (obj
));
14722 case 't': /* indicate TEXT or BINARY */
14723 #ifdef MODE_LINE_BINARY_TEXT
14724 return MODE_LINE_BINARY_TEXT (b
);
14730 /* coding-system (not including end-of-line format) */
14732 /* coding-system (including end-of-line type) */
14734 int eol_flag
= (c
== 'Z');
14735 char *p
= decode_mode_spec_buf
;
14737 if (! FRAME_WINDOW_P (f
))
14739 /* No need to mention EOL here--the terminal never needs
14740 to do EOL conversion. */
14741 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, 0);
14742 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, 0);
14744 p
= decode_mode_spec_coding (b
->buffer_file_coding_system
,
14747 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
14748 #ifdef subprocesses
14749 obj
= Fget_buffer_process (Fcurrent_buffer ());
14750 if (PROCESSP (obj
))
14752 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
14754 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
14757 #endif /* subprocesses */
14760 return decode_mode_spec_buf
;
14766 *multibyte
= STRING_MULTIBYTE (obj
);
14767 return (char *) SDATA (obj
);
14774 /* Count up to COUNT lines starting from START / START_BYTE.
14775 But don't go beyond LIMIT_BYTE.
14776 Return the number of lines thus found (always nonnegative).
14778 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
14781 display_count_lines (start
, start_byte
, limit_byte
, count
, byte_pos_ptr
)
14782 int start
, start_byte
, limit_byte
, count
;
14785 register unsigned char *cursor
;
14786 unsigned char *base
;
14788 register int ceiling
;
14789 register unsigned char *ceiling_addr
;
14790 int orig_count
= count
;
14792 /* If we are not in selective display mode,
14793 check only for newlines. */
14794 int selective_display
= (!NILP (current_buffer
->selective_display
)
14795 && !INTEGERP (current_buffer
->selective_display
));
14799 while (start_byte
< limit_byte
)
14801 ceiling
= BUFFER_CEILING_OF (start_byte
);
14802 ceiling
= min (limit_byte
- 1, ceiling
);
14803 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
14804 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
14807 if (selective_display
)
14808 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
14811 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
14814 if (cursor
!= ceiling_addr
)
14818 start_byte
+= cursor
- base
+ 1;
14819 *byte_pos_ptr
= start_byte
;
14823 if (++cursor
== ceiling_addr
)
14829 start_byte
+= cursor
- base
;
14834 while (start_byte
> limit_byte
)
14836 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
14837 ceiling
= max (limit_byte
, ceiling
);
14838 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
14839 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
14842 if (selective_display
)
14843 while (--cursor
!= ceiling_addr
14844 && *cursor
!= '\n' && *cursor
!= 015)
14847 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
14850 if (cursor
!= ceiling_addr
)
14854 start_byte
+= cursor
- base
+ 1;
14855 *byte_pos_ptr
= start_byte
;
14856 /* When scanning backwards, we should
14857 not count the newline posterior to which we stop. */
14858 return - orig_count
- 1;
14864 /* Here we add 1 to compensate for the last decrement
14865 of CURSOR, which took it past the valid range. */
14866 start_byte
+= cursor
- base
+ 1;
14870 *byte_pos_ptr
= limit_byte
;
14873 return - orig_count
+ count
;
14874 return orig_count
- count
;
14880 /***********************************************************************
14882 ***********************************************************************/
14884 /* Display a NUL-terminated string, starting with index START.
14886 If STRING is non-null, display that C string. Otherwise, the Lisp
14887 string LISP_STRING is displayed.
14889 If FACE_STRING is not nil, FACE_STRING_POS is a position in
14890 FACE_STRING. Display STRING or LISP_STRING with the face at
14891 FACE_STRING_POS in FACE_STRING:
14893 Display the string in the environment given by IT, but use the
14894 standard display table, temporarily.
14896 FIELD_WIDTH is the minimum number of output glyphs to produce.
14897 If STRING has fewer characters than FIELD_WIDTH, pad to the right
14898 with spaces. If STRING has more characters, more than FIELD_WIDTH
14899 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
14901 PRECISION is the maximum number of characters to output from
14902 STRING. PRECISION < 0 means don't truncate the string.
14904 This is roughly equivalent to printf format specifiers:
14906 FIELD_WIDTH PRECISION PRINTF
14907 ----------------------------------------
14913 MULTIBYTE zero means do not display multibyte chars, > 0 means do
14914 display them, and < 0 means obey the current buffer's value of
14915 enable_multibyte_characters.
14917 Value is the number of glyphs produced. */
14920 display_string (string
, lisp_string
, face_string
, face_string_pos
,
14921 start
, it
, field_width
, precision
, max_x
, multibyte
)
14922 unsigned char *string
;
14923 Lisp_Object lisp_string
;
14924 Lisp_Object face_string
;
14925 int face_string_pos
;
14928 int field_width
, precision
, max_x
;
14931 int hpos_at_start
= it
->hpos
;
14932 int saved_face_id
= it
->face_id
;
14933 struct glyph_row
*row
= it
->glyph_row
;
14935 /* Initialize the iterator IT for iteration over STRING beginning
14936 with index START. */
14937 reseat_to_string (it
, string
, lisp_string
, start
,
14938 precision
, field_width
, multibyte
);
14940 /* If displaying STRING, set up the face of the iterator
14941 from LISP_STRING, if that's given. */
14942 if (STRINGP (face_string
))
14948 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
14949 0, it
->region_beg_charpos
,
14950 it
->region_end_charpos
,
14951 &endptr
, it
->base_face_id
, 0);
14952 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
14953 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
14956 /* Set max_x to the maximum allowed X position. Don't let it go
14957 beyond the right edge of the window. */
14959 max_x
= it
->last_visible_x
;
14961 max_x
= min (max_x
, it
->last_visible_x
);
14963 /* Skip over display elements that are not visible. because IT->w is
14965 if (it
->current_x
< it
->first_visible_x
)
14966 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
14967 MOVE_TO_POS
| MOVE_TO_X
);
14969 row
->ascent
= it
->max_ascent
;
14970 row
->height
= it
->max_ascent
+ it
->max_descent
;
14971 row
->phys_ascent
= it
->max_phys_ascent
;
14972 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
14974 /* This condition is for the case that we are called with current_x
14975 past last_visible_x. */
14976 while (it
->current_x
< max_x
)
14978 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
14980 /* Get the next display element. */
14981 if (!get_next_display_element (it
))
14984 /* Produce glyphs. */
14985 x_before
= it
->current_x
;
14986 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
14987 PRODUCE_GLYPHS (it
);
14989 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
14992 while (i
< nglyphs
)
14994 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
14996 if (!it
->truncate_lines_p
14997 && x
+ glyph
->pixel_width
> max_x
)
14999 /* End of continued line or max_x reached. */
15000 if (CHAR_GLYPH_PADDING_P (*glyph
))
15002 /* A wide character is unbreakable. */
15003 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
15004 it
->current_x
= x_before
;
15008 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
15013 else if (x
+ glyph
->pixel_width
> it
->first_visible_x
)
15015 /* Glyph is at least partially visible. */
15017 if (x
< it
->first_visible_x
)
15018 it
->glyph_row
->x
= x
- it
->first_visible_x
;
15022 /* Glyph is off the left margin of the display area.
15023 Should not happen. */
15027 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
15028 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
15029 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
15030 row
->phys_height
= max (row
->phys_height
,
15031 it
->max_phys_ascent
+ it
->max_phys_descent
);
15032 x
+= glyph
->pixel_width
;
15036 /* Stop if max_x reached. */
15040 /* Stop at line ends. */
15041 if (ITERATOR_AT_END_OF_LINE_P (it
))
15043 it
->continuation_lines_width
= 0;
15047 set_iterator_to_next (it
, 1);
15049 /* Stop if truncating at the right edge. */
15050 if (it
->truncate_lines_p
15051 && it
->current_x
>= it
->last_visible_x
)
15053 /* Add truncation mark, but don't do it if the line is
15054 truncated at a padding space. */
15055 if (IT_CHARPOS (*it
) < it
->string_nchars
)
15057 if (!FRAME_WINDOW_P (it
->f
))
15061 if (it
->current_x
> it
->last_visible_x
)
15063 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
15064 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
15066 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
15068 row
->used
[TEXT_AREA
] = i
;
15069 produce_special_glyphs (it
, IT_TRUNCATION
);
15072 produce_special_glyphs (it
, IT_TRUNCATION
);
15074 it
->glyph_row
->truncated_on_right_p
= 1;
15080 /* Maybe insert a truncation at the left. */
15081 if (it
->first_visible_x
15082 && IT_CHARPOS (*it
) > 0)
15084 if (!FRAME_WINDOW_P (it
->f
))
15085 insert_left_trunc_glyphs (it
);
15086 it
->glyph_row
->truncated_on_left_p
= 1;
15089 it
->face_id
= saved_face_id
;
15091 /* Value is number of columns displayed. */
15092 return it
->hpos
- hpos_at_start
;
15097 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
15098 appears as an element of LIST or as the car of an element of LIST.
15099 If PROPVAL is a list, compare each element against LIST in that
15100 way, and return 1/2 if any element of PROPVAL is found in LIST.
15101 Otherwise return 0. This function cannot quit.
15102 The return value is 2 if the text is invisible but with an ellipsis
15103 and 1 if it's invisible and without an ellipsis. */
15106 invisible_p (propval
, list
)
15107 register Lisp_Object propval
;
15110 register Lisp_Object tail
, proptail
;
15112 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
15114 register Lisp_Object tem
;
15116 if (EQ (propval
, tem
))
15118 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
15119 return NILP (XCDR (tem
)) ? 1 : 2;
15122 if (CONSP (propval
))
15124 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
15126 Lisp_Object propelt
;
15127 propelt
= XCAR (proptail
);
15128 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
15130 register Lisp_Object tem
;
15132 if (EQ (propelt
, tem
))
15134 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
15135 return NILP (XCDR (tem
)) ? 1 : 2;
15144 /***********************************************************************
15146 ***********************************************************************/
15151 Vwith_echo_area_save_vector
= Qnil
;
15152 staticpro (&Vwith_echo_area_save_vector
);
15154 Vmessage_stack
= Qnil
;
15155 staticpro (&Vmessage_stack
);
15157 Qinhibit_redisplay
= intern ("inhibit-redisplay");
15158 staticpro (&Qinhibit_redisplay
);
15160 message_dolog_marker1
= Fmake_marker ();
15161 staticpro (&message_dolog_marker1
);
15162 message_dolog_marker2
= Fmake_marker ();
15163 staticpro (&message_dolog_marker2
);
15164 message_dolog_marker3
= Fmake_marker ();
15165 staticpro (&message_dolog_marker3
);
15168 defsubr (&Sdump_frame_glyph_matrix
);
15169 defsubr (&Sdump_glyph_matrix
);
15170 defsubr (&Sdump_glyph_row
);
15171 defsubr (&Sdump_tool_bar_row
);
15172 defsubr (&Strace_redisplay
);
15173 defsubr (&Strace_to_stderr
);
15175 #ifdef HAVE_WINDOW_SYSTEM
15176 defsubr (&Stool_bar_lines_needed
);
15178 defsubr (&Sformat_mode_line
);
15180 staticpro (&Qmenu_bar_update_hook
);
15181 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
15183 staticpro (&Qoverriding_terminal_local_map
);
15184 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
15186 staticpro (&Qoverriding_local_map
);
15187 Qoverriding_local_map
= intern ("overriding-local-map");
15189 staticpro (&Qwindow_scroll_functions
);
15190 Qwindow_scroll_functions
= intern ("window-scroll-functions");
15192 staticpro (&Qredisplay_end_trigger_functions
);
15193 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
15195 staticpro (&Qinhibit_point_motion_hooks
);
15196 Qinhibit_point_motion_hooks
= intern ("inhibit-point-motion-hooks");
15198 QCdata
= intern (":data");
15199 staticpro (&QCdata
);
15200 Qdisplay
= intern ("display");
15201 staticpro (&Qdisplay
);
15202 Qspace_width
= intern ("space-width");
15203 staticpro (&Qspace_width
);
15204 Qraise
= intern ("raise");
15205 staticpro (&Qraise
);
15206 Qspace
= intern ("space");
15207 staticpro (&Qspace
);
15208 Qmargin
= intern ("margin");
15209 staticpro (&Qmargin
);
15210 Qleft_margin
= intern ("left-margin");
15211 staticpro (&Qleft_margin
);
15212 Qright_margin
= intern ("right-margin");
15213 staticpro (&Qright_margin
);
15214 Qalign_to
= intern ("align-to");
15215 staticpro (&Qalign_to
);
15216 QCalign_to
= intern (":align-to");
15217 staticpro (&QCalign_to
);
15218 Qrelative_width
= intern ("relative-width");
15219 staticpro (&Qrelative_width
);
15220 QCrelative_width
= intern (":relative-width");
15221 staticpro (&QCrelative_width
);
15222 QCrelative_height
= intern (":relative-height");
15223 staticpro (&QCrelative_height
);
15224 QCeval
= intern (":eval");
15225 staticpro (&QCeval
);
15226 QCpropertize
= intern (":propertize");
15227 staticpro (&QCpropertize
);
15228 Qwhen
= intern ("when");
15229 staticpro (&Qwhen
);
15230 QCfile
= intern (":file");
15231 staticpro (&QCfile
);
15232 Qfontified
= intern ("fontified");
15233 staticpro (&Qfontified
);
15234 Qfontification_functions
= intern ("fontification-functions");
15235 staticpro (&Qfontification_functions
);
15236 Qtrailing_whitespace
= intern ("trailing-whitespace");
15237 staticpro (&Qtrailing_whitespace
);
15238 Qimage
= intern ("image");
15239 staticpro (&Qimage
);
15240 Qmessage_truncate_lines
= intern ("message-truncate-lines");
15241 staticpro (&Qmessage_truncate_lines
);
15242 Qcursor_in_non_selected_windows
= intern ("cursor-in-non-selected-windows");
15243 staticpro (&Qcursor_in_non_selected_windows
);
15244 Qgrow_only
= intern ("grow-only");
15245 staticpro (&Qgrow_only
);
15246 Qinhibit_menubar_update
= intern ("inhibit-menubar-update");
15247 staticpro (&Qinhibit_menubar_update
);
15248 Qinhibit_eval_during_redisplay
= intern ("inhibit-eval-during-redisplay");
15249 staticpro (&Qinhibit_eval_during_redisplay
);
15250 Qposition
= intern ("position");
15251 staticpro (&Qposition
);
15252 Qbuffer_position
= intern ("buffer-position");
15253 staticpro (&Qbuffer_position
);
15254 Qobject
= intern ("object");
15255 staticpro (&Qobject
);
15256 Qrisky_local_variable
= intern ("risky-local-variable");
15257 staticpro (&Qrisky_local_variable
);
15259 list_of_error
= Fcons (intern ("error"), Qnil
);
15260 staticpro (&list_of_error
);
15262 last_arrow_position
= Qnil
;
15263 last_arrow_string
= Qnil
;
15264 staticpro (&last_arrow_position
);
15265 staticpro (&last_arrow_string
);
15267 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
15268 staticpro (&echo_buffer
[0]);
15269 staticpro (&echo_buffer
[1]);
15271 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
15272 staticpro (&echo_area_buffer
[0]);
15273 staticpro (&echo_area_buffer
[1]);
15275 Vmessages_buffer_name
= build_string ("*Messages*");
15276 staticpro (&Vmessages_buffer_name
);
15278 mode_line_proptrans_alist
= Qnil
;
15279 staticpro (&mode_line_proptrans_alist
);
15281 mode_line_string_list
= Qnil
;
15282 staticpro (&mode_line_string_list
);
15284 DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace
,
15285 doc
: /* Non-nil means highlight trailing whitespace.
15286 The face used for trailing whitespace is `trailing-whitespace'. */);
15287 Vshow_trailing_whitespace
= Qnil
;
15289 DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay
,
15290 doc
: /* Non-nil means don't actually do any redisplay.
15291 This is used for internal purposes. */);
15292 Vinhibit_redisplay
= Qnil
;
15294 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
15295 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
15296 Vglobal_mode_string
= Qnil
;
15298 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
15299 doc
: /* Marker for where to display an arrow on top of the buffer text.
15300 This must be the beginning of a line in order to work.
15301 See also `overlay-arrow-string'. */);
15302 Voverlay_arrow_position
= Qnil
;
15304 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
15305 doc
: /* String to display as an arrow. See also `overlay-arrow-position'. */);
15306 Voverlay_arrow_string
= Qnil
;
15308 DEFVAR_INT ("scroll-step", &scroll_step
,
15309 doc
: /* *The number of lines to try scrolling a window by when point moves out.
15310 If that fails to bring point back on frame, point is centered instead.
15311 If this is zero, point is always centered after it moves off frame.
15312 If you want scrolling to always be a line at a time, you should set
15313 `scroll-conservatively' to a large value rather than set this to 1. */);
15315 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
15316 doc
: /* *Scroll up to this many lines, to bring point back on screen.
15317 A value of zero means to scroll the text to center point vertically
15318 in the window. */);
15319 scroll_conservatively
= 0;
15321 DEFVAR_INT ("scroll-margin", &scroll_margin
,
15322 doc
: /* *Number of lines of margin at the top and bottom of a window.
15323 Recenter the window whenever point gets within this many lines
15324 of the top or bottom of the window. */);
15328 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, doc
: /* Don't ask. */);
15331 DEFVAR_BOOL ("truncate-partial-width-windows",
15332 &truncate_partial_width_windows
,
15333 doc
: /* *Non-nil means truncate lines in all windows less than full frame wide. */);
15334 truncate_partial_width_windows
= 1;
15336 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
15337 doc
: /* nil means display the mode-line/header-line/menu-bar in the default face.
15338 Any other value means to use the appropriate face, `mode-line',
15339 `header-line', or `menu' respectively. */);
15340 mode_line_inverse_video
= 1;
15342 DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit
,
15343 doc
: /* *Maximum buffer size for which line number should be displayed.
15344 If the buffer is bigger than this, the line number does not appear
15345 in the mode line. A value of nil means no limit. */);
15346 Vline_number_display_limit
= Qnil
;
15348 DEFVAR_INT ("line-number-display-limit-width",
15349 &line_number_display_limit_width
,
15350 doc
: /* *Maximum line width (in characters) for line number display.
15351 If the average length of the lines near point is bigger than this, then the
15352 line number may be omitted from the mode line. */);
15353 line_number_display_limit_width
= 200;
15355 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
15356 doc
: /* *Non-nil means highlight region even in nonselected windows. */);
15357 highlight_nonselected_windows
= 0;
15359 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
15360 doc
: /* Non-nil if more than one frame is visible on this display.
15361 Minibuffer-only frames don't count, but iconified frames do.
15362 This variable is not guaranteed to be accurate except while processing
15363 `frame-title-format' and `icon-title-format'. */);
15365 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
15366 doc
: /* Template for displaying the title bar of visible frames.
15367 \(Assuming the window manager supports this feature.)
15368 This variable has the same structure as `mode-line-format' (which see),
15369 and is used only on frames for which no explicit name has been set
15370 \(see `modify-frame-parameters'). */);
15371 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
15372 doc
: /* Template for displaying the title bar of an iconified frame.
15373 \(Assuming the window manager supports this feature.)
15374 This variable has the same structure as `mode-line-format' (which see),
15375 and is used only on frames for which no explicit name has been set
15376 \(see `modify-frame-parameters'). */);
15378 = Vframe_title_format
15379 = Fcons (intern ("multiple-frames"),
15380 Fcons (build_string ("%b"),
15381 Fcons (Fcons (empty_string
,
15382 Fcons (intern ("invocation-name"),
15383 Fcons (build_string ("@"),
15384 Fcons (intern ("system-name"),
15388 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
15389 doc
: /* Maximum number of lines to keep in the message log buffer.
15390 If nil, disable message logging. If t, log messages but don't truncate
15391 the buffer when it becomes large. */);
15392 Vmessage_log_max
= make_number (50);
15394 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
15395 doc
: /* Functions called before redisplay, if window sizes have changed.
15396 The value should be a list of functions that take one argument.
15397 Just before redisplay, for each frame, if any of its windows have changed
15398 size since the last redisplay, or have been split or deleted,
15399 all the functions in the list are called, with the frame as argument. */);
15400 Vwindow_size_change_functions
= Qnil
;
15402 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
15403 doc
: /* List of Functions to call before redisplaying a window with scrolling.
15404 Each function is called with two arguments, the window
15405 and its new display-start position. Note that the value of `window-end'
15406 is not valid when these functions are called. */);
15407 Vwindow_scroll_functions
= Qnil
;
15409 DEFVAR_BOOL ("auto-resize-tool-bars", &auto_resize_tool_bars_p
,
15410 doc
: /* *Non-nil means automatically resize tool-bars.
15411 This increases a tool-bar's height if not all tool-bar items are visible.
15412 It decreases a tool-bar's height when it would display blank lines
15414 auto_resize_tool_bars_p
= 1;
15416 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p
,
15417 doc
: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
15418 auto_raise_tool_bar_buttons_p
= 1;
15420 DEFVAR_LISP ("tool-bar-button-margin", &Vtool_bar_button_margin
,
15421 doc
: /* *Margin around tool-bar buttons in pixels.
15422 If an integer, use that for both horizontal and vertical margins.
15423 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
15424 HORZ specifying the horizontal margin, and VERT specifying the
15425 vertical margin. */);
15426 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
15428 DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief
,
15429 doc
: /* *Relief thickness of tool-bar buttons. */);
15430 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
15432 DEFVAR_LISP ("fontification-functions", &Vfontification_functions
,
15433 doc
: /* List of functions to call to fontify regions of text.
15434 Each function is called with one argument POS. Functions must
15435 fontify a region starting at POS in the current buffer, and give
15436 fontified regions the property `fontified'. */);
15437 Vfontification_functions
= Qnil
;
15438 Fmake_variable_buffer_local (Qfontification_functions
);
15440 DEFVAR_BOOL ("unibyte-display-via-language-environment",
15441 &unibyte_display_via_language_environment
,
15442 doc
: /* *Non-nil means display unibyte text according to language environment.
15443 Specifically this means that unibyte non-ASCII characters
15444 are displayed by converting them to the equivalent multibyte characters
15445 according to the current language environment. As a result, they are
15446 displayed according to the current fontset. */);
15447 unibyte_display_via_language_environment
= 0;
15449 DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height
,
15450 doc
: /* *Maximum height for resizing mini-windows.
15451 If a float, it specifies a fraction of the mini-window frame's height.
15452 If an integer, it specifies a number of lines. */);
15453 Vmax_mini_window_height
= make_float (0.25);
15455 DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows
,
15456 doc
: /* *How to resize mini-windows.
15457 A value of nil means don't automatically resize mini-windows.
15458 A value of t means resize them to fit the text displayed in them.
15459 A value of `grow-only', the default, means let mini-windows grow
15460 only, until their display becomes empty, at which point the windows
15461 go back to their normal size. */);
15462 Vresize_mini_windows
= Qgrow_only
;
15464 DEFVAR_BOOL ("cursor-in-non-selected-windows",
15465 &cursor_in_non_selected_windows
,
15466 doc
: /* *Non-nil means display a hollow cursor in non-selected windows.
15467 nil means don't display a cursor there. */);
15468 cursor_in_non_selected_windows
= 1;
15470 DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p
,
15471 doc
: /* *Non-nil means scroll the display automatically to make point visible. */);
15472 automatic_hscrolling_p
= 1;
15474 DEFVAR_INT ("hscroll-margin", &hscroll_margin
,
15475 doc
: /* *How many columns away from the window edge point is allowed to get
15476 before automatic hscrolling will horizontally scroll the window. */);
15477 hscroll_margin
= 5;
15479 DEFVAR_LISP ("hscroll-step", &Vhscroll_step
,
15480 doc
: /* *How many columns to scroll the window when point gets too close to the edge.
15481 When point is less than `automatic-hscroll-margin' columns from the window
15482 edge, automatic hscrolling will scroll the window by the amount of columns
15483 determined by this variable. If its value is a positive integer, scroll that
15484 many columns. If it's a positive floating-point number, it specifies the
15485 fraction of the window's width to scroll. If it's nil or zero, point will be
15486 centered horizontally after the scroll. Any other value, including negative
15487 numbers, are treated as if the value were zero.
15489 Automatic hscrolling always moves point outside the scroll margin, so if
15490 point was more than scroll step columns inside the margin, the window will
15491 scroll more than the value given by the scroll step.
15493 Note that the lower bound for automatic hscrolling specified by `scroll-left'
15494 and `scroll-right' overrides this variable's effect. */);
15495 Vhscroll_step
= make_number (0);
15497 DEFVAR_LISP ("image-types", &Vimage_types
,
15498 doc
: /* List of supported image types.
15499 Each element of the list is a symbol for a supported image type. */);
15500 Vimage_types
= Qnil
;
15502 DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines
,
15503 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
15504 Bind this around calls to `message' to let it take effect. */);
15505 message_truncate_lines
= 0;
15507 DEFVAR_LISP ("menu-bar-update-hook", &Vmenu_bar_update_hook
,
15508 doc
: /* Normal hook run for clicks on menu bar, before displaying a submenu.
15509 Can be used to update submenus whose contents should vary. */);
15510 Vmenu_bar_update_hook
= Qnil
;
15512 DEFVAR_BOOL ("inhibit-menubar-update", &inhibit_menubar_update
,
15513 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
15514 inhibit_menubar_update
= 0;
15516 DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay
,
15517 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
15518 inhibit_eval_during_redisplay
= 0;
15521 DEFVAR_BOOL ("inhibit-try-window-id", &inhibit_try_window_id
,
15522 doc
: /* Inhibit try_window_id display optimization. */);
15523 inhibit_try_window_id
= 0;
15525 DEFVAR_BOOL ("inhibit-try-window-reusing", &inhibit_try_window_reusing
,
15526 doc
: /* Inhibit try_window_reusing display optimization. */);
15527 inhibit_try_window_reusing
= 0;
15529 DEFVAR_BOOL ("inhibit-try-cursor-movement", &inhibit_try_cursor_movement
,
15530 doc
: /* Inhibit try_cursor_movement display optimization. */);
15531 inhibit_try_cursor_movement
= 0;
15532 #endif /* GLYPH_DEBUG */
15536 /* Initialize this module when Emacs starts. */
15541 Lisp_Object root_window
;
15542 struct window
*mini_w
;
15544 current_header_line_height
= current_mode_line_height
= -1;
15546 CHARPOS (this_line_start_pos
) = 0;
15548 mini_w
= XWINDOW (minibuf_window
);
15549 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
15551 if (!noninteractive
)
15553 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
15556 XWINDOW (root_window
)->top
= make_number (FRAME_TOP_MARGIN (f
));
15557 set_window_height (root_window
,
15558 FRAME_HEIGHT (f
) - 1 - FRAME_TOP_MARGIN (f
),
15560 mini_w
->top
= make_number (FRAME_HEIGHT (f
) - 1);
15561 set_window_height (minibuf_window
, 1, 0);
15563 XWINDOW (root_window
)->width
= make_number (FRAME_WIDTH (f
));
15564 mini_w
->width
= make_number (FRAME_WIDTH (f
));
15566 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
15567 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
15568 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
15570 /* The default ellipsis glyphs `...'. */
15571 for (i
= 0; i
< 3; ++i
)
15572 default_invis_vector
[i
] = make_number ('.');
15576 /* Allocate the buffer for frame titles.
15577 Also used for `format-mode-line'. */
15579 frame_title_buf
= (char *) xmalloc (size
);
15580 frame_title_buf_end
= frame_title_buf
+ size
;
15581 frame_title_ptr
= NULL
;
15584 help_echo_showing_p
= 0;