1 /* Display generation from window structure and buffer text.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* New 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 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 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 be displayed is then simple. It is
127 started by initializing an iterator with a call to init_iterator
128 (or init_string_iterator for that matter). Calls to
129 get_next_display_element fill the iterator structure with relevant
130 information about the next thing to display. Calls to
131 set_iterator_to_next move the iterator to the next thing.
133 Besides this, an iterator also contains information about the
134 display environment in which glyphs for display elements are to be
135 produced. It has fields for the width and height of the display,
136 the information whether long lines are truncated or continued, a
137 current X and Y position, and lots of other stuff you can better
140 Glyphs in a desired matrix are normally constructed in a loop
141 calling get_next_display_element and then produce_glyphs. The call
142 to produce_glyphs will fill the iterator structure with pixel
143 information about the element being displayed and at the same time
144 produce glyphs for it. If the display element fits on the line
145 being displayed, set_iterator_to_next is called next, otherwise the
146 glyphs produced are discarded.
151 That just couldn't be all, could it? What about terminal types not
152 supporting operations on sub-windows of the screen? To update the
153 display on such a terminal, window-based glyph matrices are not
154 well suited. To be able to reuse part of the display (scrolling
155 lines up and down), we must instead have a view of the whole
156 screen. This is what `frame matrices' are for. They are a trick.
158 Frames on terminals like above have a glyph pool. Windows on such
159 a frame sub-allocate their glyph memory from their frame's glyph
160 pool. The frame itself is given its own glyph matrices. By
161 coincidence---or maybe something else---rows in window glyph
162 matrices are slices of corresponding rows in frame matrices. Thus
163 writing to window matrices implicitly updates a frame matrix which
164 provides us with the view of the whole screen that we originally
165 wanted to have without having to move many bytes around. To be
166 honest, there is a little bit more done, but not much more. If you
167 plan to extend that code, take a look at dispnew.c. The function
168 build_frame_matrix is a good starting point. */
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 min(a, b) ((a) < (b) ? (a) : (b))
202 #define max(a, b) ((a) > (b) ? (a) : (b))
204 #define INFINITY 10000000
206 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
207 extern void set_frame_menubar
P_ ((struct frame
*f
, int, int));
208 extern int pending_menu_activation
;
211 extern int interrupt_input
;
212 extern int command_loop_level
;
214 extern int minibuffer_auto_raise
;
216 extern Lisp_Object Qface
;
218 extern Lisp_Object Voverriding_local_map
;
219 extern Lisp_Object Voverriding_local_map_menu_flag
;
220 extern Lisp_Object Qmenu_item
;
222 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
223 Lisp_Object Qwindow_scroll_functions
, Vwindow_scroll_functions
;
224 Lisp_Object Qredisplay_end_trigger_functions
;
225 Lisp_Object Qinhibit_point_motion_hooks
;
226 Lisp_Object QCeval
, Qwhen
, QCfile
, QCdata
;
227 Lisp_Object Qfontified
;
228 Lisp_Object Qgrow_only
;
230 /* Functions called to fontify regions of text. */
232 Lisp_Object Vfontification_functions
;
233 Lisp_Object Qfontification_functions
;
235 /* Non-zero means draw tool bar buttons raised when the mouse moves
238 int auto_raise_tool_bar_buttons_p
;
240 /* Margin around tool bar buttons in pixels. */
242 int tool_bar_button_margin
;
244 /* Thickness of shadow to draw around tool bar buttons. */
246 int tool_bar_button_relief
;
248 /* Non-zero means automatically resize tool-bars so that all tool-bar
249 items are visible, and no blank lines remain. */
251 int auto_resize_tool_bars_p
;
253 /* Non-nil means don't actually do any redisplay. */
255 Lisp_Object Vinhibit_redisplay
, Qinhibit_redisplay
;
257 /* Names of text properties relevant for redisplay. */
259 Lisp_Object Qdisplay
, Qrelative_width
, Qalign_to
;
260 extern Lisp_Object Qface
, Qinvisible
, Qimage
, Qwidth
;
262 /* Symbols used in text property values. */
264 Lisp_Object Qspace
, QCalign_to
, QCrelative_width
, QCrelative_height
;
265 Lisp_Object Qleft_margin
, Qright_margin
, Qspace_width
, Qraise
;
267 extern Lisp_Object Qheight
;
269 /* Non-nil means highlight trailing whitespace. */
271 Lisp_Object Vshow_trailing_whitespace
;
273 /* Name of the face used to highlight trailing whitespace. */
275 Lisp_Object Qtrailing_whitespace
;
277 /* The symbol `image' which is the car of the lists used to represent
282 /* Non-zero means print newline to stdout before next mini-buffer
285 int noninteractive_need_newline
;
287 /* Non-zero means print newline to message log before next message. */
289 static int message_log_need_newline
;
292 /* The buffer position of the first character appearing entirely or
293 partially on the line of the selected window which contains the
294 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
295 redisplay optimization in redisplay_internal. */
297 static struct text_pos this_line_start_pos
;
299 /* Number of characters past the end of the line above, including the
300 terminating newline. */
302 static struct text_pos this_line_end_pos
;
304 /* The vertical positions and the height of this line. */
306 static int this_line_vpos
;
307 static int this_line_y
;
308 static int this_line_pixel_height
;
310 /* X position at which this display line starts. Usually zero;
311 negative if first character is partially visible. */
313 static int this_line_start_x
;
315 /* Buffer that this_line_.* variables are referring to. */
317 static struct buffer
*this_line_buffer
;
319 /* Nonzero means truncate lines in all windows less wide than the
322 int truncate_partial_width_windows
;
324 /* A flag to control how to display unibyte 8-bit character. */
326 int unibyte_display_via_language_environment
;
328 /* Nonzero means we have more than one non-mini-buffer-only frame.
329 Not guaranteed to be accurate except while parsing
330 frame-title-format. */
334 Lisp_Object Vglobal_mode_string
;
336 /* Marker for where to display an arrow on top of the buffer text. */
338 Lisp_Object Voverlay_arrow_position
;
340 /* String to display for the arrow. Only used on terminal frames. */
342 Lisp_Object Voverlay_arrow_string
;
344 /* Values of those variables at last redisplay. However, if
345 Voverlay_arrow_position is a marker, last_arrow_position is its
346 numerical position. */
348 static Lisp_Object last_arrow_position
, last_arrow_string
;
350 /* Like mode-line-format, but for the title bar on a visible frame. */
352 Lisp_Object Vframe_title_format
;
354 /* Like mode-line-format, but for the title bar on an iconified frame. */
356 Lisp_Object Vicon_title_format
;
358 /* List of functions to call when a window's size changes. These
359 functions get one arg, a frame on which one or more windows' sizes
362 static Lisp_Object Vwindow_size_change_functions
;
364 Lisp_Object Qmenu_bar_update_hook
, Vmenu_bar_update_hook
;
366 /* Nonzero if overlay arrow has been displayed once in this window. */
368 static int overlay_arrow_seen
;
370 /* Nonzero means highlight the region even in nonselected windows. */
372 int highlight_nonselected_windows
;
374 /* If cursor motion alone moves point off frame, try scrolling this
375 many lines up or down if that will bring it back. */
377 static int scroll_step
;
379 /* Non-0 means scroll just far enough to bring point back on the
380 screen, when appropriate. */
382 static int scroll_conservatively
;
384 /* Recenter the window whenever point gets within this many lines of
385 the top or bottom of the window. This value is translated into a
386 pixel value by multiplying it with CANON_Y_UNIT, which means that
387 there is really a fixed pixel height scroll margin. */
391 /* Number of windows showing the buffer of the selected window (or
392 another buffer with the same base buffer). keyboard.c refers to
397 /* Vector containing glyphs for an ellipsis `...'. */
399 static Lisp_Object default_invis_vector
[3];
401 /* Zero means display the mode-line/header-line/menu-bar in the default face
402 (this slightly odd definition is for compatibility with previous versions
403 of emacs), non-zero means display them using their respective faces.
405 This variable is deprecated. */
407 int mode_line_inverse_video
;
409 /* Prompt to display in front of the mini-buffer contents. */
411 Lisp_Object minibuf_prompt
;
413 /* Width of current mini-buffer prompt. Only set after display_line
414 of the line that contains the prompt. */
416 int minibuf_prompt_width
;
417 int minibuf_prompt_pixel_width
;
419 /* This is the window where the echo area message was displayed. It
420 is always a mini-buffer window, but it may not be the same window
421 currently active as a mini-buffer. */
423 Lisp_Object echo_area_window
;
425 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
426 pushes the current message and the value of
427 message_enable_multibyte on the stack, the function restore_message
428 pops the stack and displays MESSAGE again. */
430 Lisp_Object Vmessage_stack
;
432 /* Nonzero means multibyte characters were enabled when the echo area
433 message was specified. */
435 int message_enable_multibyte
;
437 /* True if we should redraw the mode lines on the next redisplay. */
439 int update_mode_lines
;
441 /* Nonzero if window sizes or contents have changed since last
442 redisplay that finished */
444 int windows_or_buffers_changed
;
446 /* Nonzero after display_mode_line if %l was used and it displayed a
449 int line_number_displayed
;
451 /* Maximum buffer size for which to display line numbers. */
453 Lisp_Object Vline_number_display_limit
;
455 /* line width to consider when repostioning for line number display */
457 static int line_number_display_limit_width
;
459 /* Number of lines to keep in the message log buffer. t means
460 infinite. nil means don't log at all. */
462 Lisp_Object Vmessage_log_max
;
464 /* The name of the *Messages* buffer, a string. */
466 static Lisp_Object Vmessages_buffer_name
;
468 /* Current, index 0, and last displayed echo area message. Either
469 buffers from echo_buffers, or nil to indicate no message. */
471 Lisp_Object echo_area_buffer
[2];
473 /* The buffers referenced from echo_area_buffer. */
475 static Lisp_Object echo_buffer
[2];
477 /* A vector saved used in with_area_buffer to reduce consing. */
479 static Lisp_Object Vwith_echo_area_save_vector
;
481 /* Non-zero means display_echo_area should display the last echo area
482 message again. Set by redisplay_preserve_echo_area. */
484 static int display_last_displayed_message_p
;
486 /* Nonzero if echo area is being used by print; zero if being used by
489 int message_buf_print
;
491 /* Maximum height for resizing mini-windows. Either a float
492 specifying a fraction of the available height, or an integer
493 specifying a number of lines. */
495 Lisp_Object Vmax_mini_window_height
;
497 /* Non-zero means messages should be displayed with truncated
498 lines instead of being continued. */
500 int message_truncate_lines
;
501 Lisp_Object Qmessage_truncate_lines
;
503 /* Non-zero means we want a hollow cursor in windows that are not
504 selected. Zero means there's no cursor in such windows. */
506 int cursor_in_non_selected_windows
;
508 /* A scratch glyph row with contents used for generating truncation
509 glyphs. Also used in direct_output_for_insert. */
511 #define MAX_SCRATCH_GLYPHS 100
512 struct glyph_row scratch_glyph_row
;
513 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
515 /* Ascent and height of the last line processed by move_it_to. */
517 static int last_max_ascent
, last_height
;
519 /* Non-zero if there's a help-echo in the echo area. */
521 int help_echo_showing_p
;
523 /* If >= 0, computed, exact values of mode-line and header-line height
524 to use in the macros CURRENT_MODE_LINE_HEIGHT and
525 CURRENT_HEADER_LINE_HEIGHT. */
527 int current_mode_line_height
, current_header_line_height
;
529 /* The maximum distance to look ahead for text properties. Values
530 that are too small let us call compute_char_face and similar
531 functions too often which is expensive. Values that are too large
532 let us call compute_char_face and alike too often because we
533 might not be interested in text properties that far away. */
535 #define TEXT_PROP_DISTANCE_LIMIT 100
539 /* Non-zero means print traces of redisplay if compiled with
542 int trace_redisplay_p
;
544 #endif /* GLYPH_DEBUG */
546 #ifdef DEBUG_TRACE_MOVE
547 /* Non-zero means trace with TRACE_MOVE to stderr. */
550 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
552 #define TRACE_MOVE(x) (void) 0
555 /* Non-zero means automatically scroll windows horizontally to make
558 int automatic_hscrolling_p
;
560 /* A list of symbols, one for each supported image type. */
562 Lisp_Object Vimage_types
;
564 /* The variable `resize-mini-windows'. If nil, don't resize
565 mini-windows. If t, always resize them to fit the text they
566 display. If `grow-only', let mini-windows grow only until they
569 Lisp_Object Vresize_mini_windows
;
571 /* Value returned from text property handlers (see below). */
576 HANDLED_RECOMPUTE_PROPS
,
577 HANDLED_OVERLAY_STRING_CONSUMED
,
581 /* A description of text properties that redisplay is interested
586 /* The name of the property. */
589 /* A unique index for the property. */
592 /* A handler function called to set up iterator IT from the property
593 at IT's current position. Value is used to steer handle_stop. */
594 enum prop_handled (*handler
) P_ ((struct it
*it
));
597 static enum prop_handled handle_face_prop
P_ ((struct it
*));
598 static enum prop_handled handle_invisible_prop
P_ ((struct it
*));
599 static enum prop_handled handle_display_prop
P_ ((struct it
*));
600 static enum prop_handled handle_composition_prop
P_ ((struct it
*));
601 static enum prop_handled handle_overlay_change
P_ ((struct it
*));
602 static enum prop_handled handle_fontified_prop
P_ ((struct it
*));
604 /* Properties handled by iterators. */
606 static struct props it_props
[] =
608 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
609 /* Handle `face' before `display' because some sub-properties of
610 `display' need to know the face. */
611 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
612 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
613 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
614 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
618 /* Value is the position described by X. If X is a marker, value is
619 the marker_position of X. Otherwise, value is X. */
621 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
623 /* Enumeration returned by some move_it_.* functions internally. */
627 /* Not used. Undefined value. */
630 /* Move ended at the requested buffer position or ZV. */
631 MOVE_POS_MATCH_OR_ZV
,
633 /* Move ended at the requested X pixel position. */
636 /* Move within a line ended at the end of a line that must be
640 /* Move within a line ended at the end of a line that would
641 be displayed truncated. */
644 /* Move within a line ended at a line end. */
650 /* Function prototypes. */
652 static int cursor_row_p
P_ ((struct window
*, struct glyph_row
*));
653 static int redisplay_mode_lines
P_ ((Lisp_Object
, int));
654 static char *decode_mode_spec_coding
P_ ((Lisp_Object
, char *, int));
655 static int invisible_text_between_p
P_ ((struct it
*, int, int));
656 static int next_element_from_ellipsis
P_ ((struct it
*));
657 static void pint2str
P_ ((char *, int, int));
658 static struct text_pos run_window_scroll_functions
P_ ((Lisp_Object
,
660 static void reconsider_clip_changes
P_ ((struct window
*, struct buffer
*));
661 static int text_outside_line_unchanged_p
P_ ((struct window
*, int, int));
662 static void store_frame_title_char
P_ ((char));
663 static int store_frame_title
P_ ((unsigned char *, int, int));
664 static void x_consider_frame_title
P_ ((Lisp_Object
));
665 static void handle_stop
P_ ((struct it
*));
666 static int tool_bar_lines_needed
P_ ((struct frame
*));
667 static int single_display_prop_intangible_p
P_ ((Lisp_Object
));
668 static void ensure_echo_area_buffers
P_ ((void));
669 static struct glyph_row
*row_containing_pos
P_ ((struct window
*, int,
671 struct glyph_row
*));
672 static Lisp_Object unwind_with_echo_area_buffer
P_ ((Lisp_Object
));
673 static Lisp_Object with_echo_area_buffer_unwind_data
P_ ((struct window
*));
674 static int with_echo_area_buffer
P_ ((struct window
*, int,
675 int (*) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
676 EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
677 static void clear_garbaged_frames
P_ ((void));
678 static int current_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
679 static int truncate_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
680 static int set_message_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
681 static int display_echo_area
P_ ((struct window
*));
682 static int display_echo_area_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
683 static int resize_mini_window_1
P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
684 static Lisp_Object unwind_redisplay
P_ ((Lisp_Object
));
685 static int string_char_and_length
P_ ((unsigned char *, int, int *));
686 static struct text_pos display_prop_end
P_ ((struct it
*, Lisp_Object
,
688 static int compute_window_start_on_continuation_line
P_ ((struct window
*));
689 static Lisp_Object safe_eval_handler
P_ ((Lisp_Object
));
690 static void insert_left_trunc_glyphs
P_ ((struct it
*));
691 static struct glyph_row
*get_overlay_arrow_glyph_row
P_ ((struct window
*));
692 static void extend_face_to_end_of_line
P_ ((struct it
*));
693 static int append_space
P_ ((struct it
*, int));
694 static void make_cursor_line_fully_visible
P_ ((struct window
*));
695 static int try_scrolling
P_ ((Lisp_Object
, int, int, int, int));
696 static int try_cursor_movement
P_ ((Lisp_Object
, struct text_pos
, int *));
697 static int trailing_whitespace_p
P_ ((int));
698 static int message_log_check_duplicate
P_ ((int, int, int, int));
699 int invisible_p
P_ ((Lisp_Object
, Lisp_Object
));
700 int invisible_ellipsis_p
P_ ((Lisp_Object
, Lisp_Object
));
701 static void push_it
P_ ((struct it
*));
702 static void pop_it
P_ ((struct it
*));
703 static void sync_frame_with_window_matrix_rows
P_ ((struct window
*));
704 static void redisplay_internal
P_ ((int));
705 static int echo_area_display
P_ ((int));
706 static void redisplay_windows
P_ ((Lisp_Object
));
707 static void redisplay_window
P_ ((Lisp_Object
, int));
708 static void update_menu_bar
P_ ((struct frame
*, int));
709 static int try_window_reusing_current_matrix
P_ ((struct window
*));
710 static int try_window_id
P_ ((struct window
*));
711 static int display_line
P_ ((struct it
*));
712 static int display_mode_lines
P_ ((struct window
*));
713 static int display_mode_line
P_ ((struct window
*, enum face_id
, Lisp_Object
));
714 static int display_mode_element
P_ ((struct it
*, int, int, int, Lisp_Object
));
715 static char *decode_mode_spec
P_ ((struct window
*, int, int, int));
716 static void display_menu_bar
P_ ((struct window
*));
717 static int display_count_lines
P_ ((int, int, int, int, int *));
718 static int display_string
P_ ((unsigned char *, Lisp_Object
, Lisp_Object
,
719 int, int, struct it
*, int, int, int, int));
720 static void compute_line_metrics
P_ ((struct it
*));
721 static void run_redisplay_end_trigger_hook
P_ ((struct it
*));
722 static int get_overlay_strings
P_ ((struct it
*));
723 static void next_overlay_string
P_ ((struct it
*));
724 static void reseat
P_ ((struct it
*, struct text_pos
, int));
725 static void reseat_1
P_ ((struct it
*, struct text_pos
, int));
726 static void back_to_previous_visible_line_start
P_ ((struct it
*));
727 static void reseat_at_previous_visible_line_start
P_ ((struct it
*));
728 static void reseat_at_next_visible_line_start
P_ ((struct it
*, int));
729 static int next_element_from_display_vector
P_ ((struct it
*));
730 static int next_element_from_string
P_ ((struct it
*));
731 static int next_element_from_c_string
P_ ((struct it
*));
732 static int next_element_from_buffer
P_ ((struct it
*));
733 static int next_element_from_composition
P_ ((struct it
*));
734 static int next_element_from_image
P_ ((struct it
*));
735 static int next_element_from_stretch
P_ ((struct it
*));
736 static void load_overlay_strings
P_ ((struct it
*));
737 static void init_from_display_pos
P_ ((struct it
*, struct window
*,
738 struct display_pos
*));
739 static void reseat_to_string
P_ ((struct it
*, unsigned char *,
740 Lisp_Object
, int, int, int, int));
741 static enum move_it_result move_it_in_display_line_to
P_ ((struct it
*,
743 void move_it_vertically_backward
P_ ((struct it
*, int));
744 static void init_to_row_start
P_ ((struct it
*, struct window
*,
745 struct glyph_row
*));
746 static void init_to_row_end
P_ ((struct it
*, struct window
*,
747 struct glyph_row
*));
748 static void back_to_previous_line_start
P_ ((struct it
*));
749 static int forward_to_next_line_start
P_ ((struct it
*, int *));
750 static struct text_pos string_pos_nchars_ahead
P_ ((struct text_pos
,
752 static struct text_pos string_pos
P_ ((int, Lisp_Object
));
753 static struct text_pos c_string_pos
P_ ((int, unsigned char *, int));
754 static int number_of_chars
P_ ((unsigned char *, int));
755 static void compute_stop_pos
P_ ((struct it
*));
756 static void compute_string_pos
P_ ((struct text_pos
*, struct text_pos
,
758 static int face_before_or_after_it_pos
P_ ((struct it
*, int));
759 static int next_overlay_change
P_ ((int));
760 static int handle_single_display_prop
P_ ((struct it
*, Lisp_Object
,
761 Lisp_Object
, struct text_pos
*));
762 static int underlying_face_id
P_ ((struct it
*));
764 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
765 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
767 #ifdef HAVE_WINDOW_SYSTEM
769 static void update_tool_bar
P_ ((struct frame
*, int));
770 static void build_desired_tool_bar_string
P_ ((struct frame
*f
));
771 static int redisplay_tool_bar
P_ ((struct frame
*));
772 static void display_tool_bar_line
P_ ((struct it
*));
774 #endif /* HAVE_WINDOW_SYSTEM */
777 /***********************************************************************
778 Window display dimensions
779 ***********************************************************************/
781 /* Return the window-relative maximum y + 1 for glyph rows displaying
782 text in window W. This is the height of W minus the height of a
783 mode line, if any. */
786 window_text_bottom_y (w
)
789 struct frame
*f
= XFRAME (w
->frame
);
790 int height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
792 if (WINDOW_WANTS_MODELINE_P (w
))
793 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
798 /* Return the pixel width of display area AREA of window W. AREA < 0
799 means return the total width of W, not including bitmap areas to
800 the left and right of the window. */
803 window_box_width (w
, area
)
807 struct frame
*f
= XFRAME (w
->frame
);
808 int width
= XFASTINT (w
->width
);
810 if (!w
->pseudo_window_p
)
812 width
-= FRAME_SCROLL_BAR_WIDTH (f
) + FRAME_FLAGS_AREA_COLS (f
);
814 if (area
== TEXT_AREA
)
816 if (INTEGERP (w
->left_margin_width
))
817 width
-= XFASTINT (w
->left_margin_width
);
818 if (INTEGERP (w
->right_margin_width
))
819 width
-= XFASTINT (w
->right_margin_width
);
821 else if (area
== LEFT_MARGIN_AREA
)
822 width
= (INTEGERP (w
->left_margin_width
)
823 ? XFASTINT (w
->left_margin_width
) : 0);
824 else if (area
== RIGHT_MARGIN_AREA
)
825 width
= (INTEGERP (w
->right_margin_width
)
826 ? XFASTINT (w
->right_margin_width
) : 0);
829 return width
* CANON_X_UNIT (f
);
833 /* Return the pixel height of the display area of window W, not
834 including mode lines of W, if any.. */
837 window_box_height (w
)
840 struct frame
*f
= XFRAME (w
->frame
);
841 int height
= XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
843 xassert (height
>= 0);
845 /* Note: the code below that determines the mode-line/header-line
846 height is essentially the same as that contained in the macro
847 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
848 the appropriate glyph row has its `mode_line_p' flag set,
849 and if it doesn't, uses estimate_mode_line_height instead. */
851 if (WINDOW_WANTS_MODELINE_P (w
))
853 struct glyph_row
*ml_row
854 = (w
->current_matrix
&& w
->current_matrix
->rows
855 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
857 if (ml_row
&& ml_row
->mode_line_p
)
858 height
-= ml_row
->height
;
860 height
-= estimate_mode_line_height (f
, MODE_LINE_FACE_ID
);
863 if (WINDOW_WANTS_HEADER_LINE_P (w
))
865 struct glyph_row
*hl_row
866 = (w
->current_matrix
&& w
->current_matrix
->rows
867 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
869 if (hl_row
&& hl_row
->mode_line_p
)
870 height
-= hl_row
->height
;
872 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
879 /* Return the frame-relative coordinate of the left edge of display
880 area AREA of window W. AREA < 0 means return the left edge of the
881 whole window, to the right of any bitmap area at the left side of
885 window_box_left (w
, area
)
889 struct frame
*f
= XFRAME (w
->frame
);
890 int x
= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
892 if (!w
->pseudo_window_p
)
894 x
+= (WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
)
895 + FRAME_LEFT_FLAGS_AREA_WIDTH (f
));
897 if (area
== TEXT_AREA
)
898 x
+= window_box_width (w
, LEFT_MARGIN_AREA
);
899 else if (area
== RIGHT_MARGIN_AREA
)
900 x
+= (window_box_width (w
, LEFT_MARGIN_AREA
)
901 + window_box_width (w
, TEXT_AREA
));
908 /* Return the frame-relative coordinate of the right edge of display
909 area AREA of window W. AREA < 0 means return the left edge of the
910 whole window, to the left of any bitmap area at the right side of
914 window_box_right (w
, area
)
918 return window_box_left (w
, area
) + window_box_width (w
, area
);
922 /* Get the bounding box of the display area AREA of window W, without
923 mode lines, in frame-relative coordinates. AREA < 0 means the
924 whole window, not including bitmap areas to the left and right of
925 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
926 coordinates of the upper-left corner of the box. Return in
927 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
930 window_box (w
, area
, box_x
, box_y
, box_width
, box_height
)
933 int *box_x
, *box_y
, *box_width
, *box_height
;
935 struct frame
*f
= XFRAME (w
->frame
);
937 *box_width
= window_box_width (w
, area
);
938 *box_height
= window_box_height (w
);
939 *box_x
= window_box_left (w
, area
);
940 *box_y
= (FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
)
941 + XFASTINT (w
->top
) * CANON_Y_UNIT (f
));
942 if (WINDOW_WANTS_HEADER_LINE_P (w
))
943 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
947 /* Get the bounding box of the display area AREA of window W, without
948 mode lines. AREA < 0 means the whole window, not including bitmap
949 areas to the left and right of the window. Return in *TOP_LEFT_X
950 and TOP_LEFT_Y the frame-relative pixel coordinates of the
951 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
952 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
956 window_box_edges (w
, area
, top_left_x
, top_left_y
,
957 bottom_right_x
, bottom_right_y
)
960 int *top_left_x
, *top_left_y
, *bottom_right_x
, *bottom_right_y
;
962 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
964 *bottom_right_x
+= *top_left_x
;
965 *bottom_right_y
+= *top_left_y
;
970 /***********************************************************************
972 ***********************************************************************/
974 /* Return 1 if position CHARPOS is visible in window W. Set *FULLY to
975 1 if POS is visible and the line containing POS is fully visible.
976 EXACT_MODE_LINE_HEIGHTS_P non-zero means compute exact mode-line
977 and header-lines heights. */
980 pos_visible_p (w
, charpos
, fully
, exact_mode_line_heights_p
)
982 int charpos
, *fully
, exact_mode_line_heights_p
;
987 struct buffer
*old_buffer
= NULL
;
989 if (XBUFFER (w
->buffer
) != current_buffer
)
991 old_buffer
= current_buffer
;
992 set_buffer_internal_1 (XBUFFER (w
->buffer
));
995 *fully
= visible_p
= 0;
996 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
998 /* Compute exact mode line heights, if requested. */
999 if (exact_mode_line_heights_p
)
1001 if (WINDOW_WANTS_MODELINE_P (w
))
1002 current_mode_line_height
1003 = display_mode_line (w
, MODE_LINE_FACE_ID
,
1004 current_buffer
->mode_line_format
);
1006 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1007 current_header_line_height
1008 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1009 current_buffer
->header_line_format
);
1012 start_display (&it
, w
, top
);
1013 move_it_to (&it
, charpos
, 0, it
.last_visible_y
, -1,
1014 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
1016 if (IT_CHARPOS (it
) == charpos
)
1018 int line_height
, line_bottom_y
;
1019 int line_top_y
= it
.current_y
;
1020 int window_top_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1022 line_height
= it
.max_ascent
+ it
.max_descent
;
1023 if (line_height
== 0)
1026 line_height
= last_height
;
1027 else if (charpos
< ZV
)
1029 move_it_by_lines (&it
, 1, 1);
1030 line_height
= (it
.max_ascent
|| it
.max_descent
1031 ? it
.max_ascent
+ it
.max_descent
1036 /* Use the default character height. */
1037 it
.what
= IT_CHARACTER
;
1040 PRODUCE_GLYPHS (&it
);
1041 line_height
= it
.ascent
+ it
.descent
;
1044 line_bottom_y
= line_top_y
+ line_height
;
1046 if (line_top_y
< window_top_y
)
1047 visible_p
= line_bottom_y
> window_top_y
;
1048 else if (line_top_y
< it
.last_visible_y
)
1051 *fully
= line_bottom_y
<= it
.last_visible_y
;
1054 else if (it
.current_y
+ it
.max_ascent
+ it
.max_descent
> it
.last_visible_y
)
1056 move_it_by_lines (&it
, 1, 0);
1057 if (charpos
< IT_CHARPOS (it
))
1065 set_buffer_internal_1 (old_buffer
);
1067 current_header_line_height
= current_mode_line_height
= -1;
1072 /* Return the next character from STR which is MAXLEN bytes long.
1073 Return in *LEN the length of the character. This is like
1074 STRING_CHAR_AND_LENGTH but never returns an invalid character. If
1075 we find one, we return a `?', but with the length of the invalid
1079 string_char_and_length (str
, maxlen
, len
)
1085 c
= STRING_CHAR_AND_LENGTH (str
, maxlen
, *len
);
1086 if (!CHAR_VALID_P (c
, 1))
1087 /* We may not change the length here because other places in Emacs
1088 don't use this function, i.e. they silently accept invalid
1097 /* Given a position POS containing a valid character and byte position
1098 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1100 static struct text_pos
1101 string_pos_nchars_ahead (pos
, string
, nchars
)
1102 struct text_pos pos
;
1106 xassert (STRINGP (string
) && nchars
>= 0);
1108 if (STRING_MULTIBYTE (string
))
1110 int rest
= STRING_BYTES (XSTRING (string
)) - BYTEPOS (pos
);
1111 unsigned char *p
= XSTRING (string
)->data
+ BYTEPOS (pos
);
1116 string_char_and_length (p
, rest
, &len
);
1117 p
+= len
, rest
-= len
;
1118 xassert (rest
>= 0);
1120 BYTEPOS (pos
) += len
;
1124 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1130 /* Value is the text position, i.e. character and byte position,
1131 for character position CHARPOS in STRING. */
1133 static INLINE
struct text_pos
1134 string_pos (charpos
, string
)
1138 struct text_pos pos
;
1139 xassert (STRINGP (string
));
1140 xassert (charpos
>= 0);
1141 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1146 /* Value is a text position, i.e. character and byte position, for
1147 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1148 means recognize multibyte characters. */
1150 static struct text_pos
1151 c_string_pos (charpos
, s
, multibyte_p
)
1156 struct text_pos pos
;
1158 xassert (s
!= NULL
);
1159 xassert (charpos
>= 0);
1163 int rest
= strlen (s
), len
;
1165 SET_TEXT_POS (pos
, 0, 0);
1168 string_char_and_length (s
, rest
, &len
);
1169 s
+= len
, rest
-= len
;
1170 xassert (rest
>= 0);
1172 BYTEPOS (pos
) += len
;
1176 SET_TEXT_POS (pos
, charpos
, charpos
);
1182 /* Value is the number of characters in C string S. MULTIBYTE_P
1183 non-zero means recognize multibyte characters. */
1186 number_of_chars (s
, multibyte_p
)
1194 int rest
= strlen (s
), len
;
1195 unsigned char *p
= (unsigned char *) s
;
1197 for (nchars
= 0; rest
> 0; ++nchars
)
1199 string_char_and_length (p
, rest
, &len
);
1200 rest
-= len
, p
+= len
;
1204 nchars
= strlen (s
);
1210 /* Compute byte position NEWPOS->bytepos corresponding to
1211 NEWPOS->charpos. POS is a known position in string STRING.
1212 NEWPOS->charpos must be >= POS.charpos. */
1215 compute_string_pos (newpos
, pos
, string
)
1216 struct text_pos
*newpos
, pos
;
1219 xassert (STRINGP (string
));
1220 xassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1222 if (STRING_MULTIBYTE (string
))
1223 *newpos
= string_pos_nchars_ahead (pos
, string
,
1224 CHARPOS (*newpos
) - CHARPOS (pos
));
1226 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1231 /***********************************************************************
1232 Lisp form evaluation
1233 ***********************************************************************/
1235 /* Error handler for safe_eval and safe_call. */
1238 safe_eval_handler (arg
)
1241 add_to_log ("Error during redisplay: %s", arg
, Qnil
);
1246 /* Evaluate SEXPR and return the result, or nil if something went
1253 int count
= BINDING_STACK_SIZE ();
1254 struct gcpro gcpro1
;
1258 specbind (Qinhibit_redisplay
, Qt
);
1259 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
, safe_eval_handler
);
1261 return unbind_to (count
, val
);
1265 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
1266 Return the result, or nil if something went wrong. */
1269 safe_call (nargs
, args
)
1273 int count
= BINDING_STACK_SIZE ();
1275 struct gcpro gcpro1
;
1278 gcpro1
.nvars
= nargs
;
1279 specbind (Qinhibit_redisplay
, Qt
);
1280 val
= internal_condition_case_2 (Ffuncall
, nargs
, args
, Qerror
,
1283 return unbind_to (count
, val
);
1287 /* Call function FN with one argument ARG.
1288 Return the result, or nil if something went wrong. */
1291 safe_call1 (fn
, arg
)
1292 Lisp_Object fn
, arg
;
1294 Lisp_Object args
[2];
1297 return safe_call (2, args
);
1302 /***********************************************************************
1304 ***********************************************************************/
1308 /* Define CHECK_IT to perform sanity checks on iterators.
1309 This is for debugging. It is too slow to do unconditionally. */
1315 if (it
->method
== next_element_from_string
)
1317 xassert (STRINGP (it
->string
));
1318 xassert (IT_STRING_CHARPOS (*it
) >= 0);
1320 else if (it
->method
== next_element_from_buffer
)
1322 /* Check that character and byte positions agree. */
1323 xassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
1327 xassert (it
->current
.dpvec_index
>= 0);
1329 xassert (it
->current
.dpvec_index
< 0);
1332 #define CHECK_IT(IT) check_it ((IT))
1336 #define CHECK_IT(IT) (void) 0
1343 /* Check that the window end of window W is what we expect it
1344 to be---the last row in the current matrix displaying text. */
1347 check_window_end (w
)
1350 if (!MINI_WINDOW_P (w
)
1351 && !NILP (w
->window_end_valid
))
1353 struct glyph_row
*row
;
1354 xassert ((row
= MATRIX_ROW (w
->current_matrix
,
1355 XFASTINT (w
->window_end_vpos
)),
1357 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1358 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
1362 #define CHECK_WINDOW_END(W) check_window_end ((W))
1364 #else /* not GLYPH_DEBUG */
1366 #define CHECK_WINDOW_END(W) (void) 0
1368 #endif /* not GLYPH_DEBUG */
1372 /***********************************************************************
1373 Iterator initialization
1374 ***********************************************************************/
1376 /* Initialize IT for displaying current_buffer in window W, starting
1377 at character position CHARPOS. CHARPOS < 0 means that no buffer
1378 position is specified which is useful when the iterator is assigned
1379 a position later. BYTEPOS is the byte position corresponding to
1380 CHARPOS. BYTEPOS <= 0 means compute it from CHARPOS.
1382 If ROW is not null, calls to produce_glyphs with IT as parameter
1383 will produce glyphs in that row.
1385 BASE_FACE_ID is the id of a base face to use. It must be one of
1386 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID or
1387 HEADER_LINE_FACE_ID for displaying mode lines, or TOOL_BAR_FACE_ID for
1388 displaying the tool-bar.
1390 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID or
1391 HEADER_LINE_FACE_ID, the iterator will be initialized to use the
1392 corresponding mode line glyph row of the desired matrix of W. */
1395 init_iterator (it
, w
, charpos
, bytepos
, row
, base_face_id
)
1398 int charpos
, bytepos
;
1399 struct glyph_row
*row
;
1400 enum face_id base_face_id
;
1402 int highlight_region_p
;
1404 /* Some precondition checks. */
1405 xassert (w
!= NULL
&& it
!= NULL
);
1406 xassert (charpos
< 0 || (charpos
> 0 && charpos
<= ZV
));
1408 /* If face attributes have been changed since the last redisplay,
1409 free realized faces now because they depend on face definitions
1410 that might have changed. */
1411 if (face_change_count
)
1413 face_change_count
= 0;
1414 free_all_realized_faces (Qnil
);
1417 /* Use one of the mode line rows of W's desired matrix if
1421 if (base_face_id
== MODE_LINE_FACE_ID
)
1422 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
1423 else if (base_face_id
== HEADER_LINE_FACE_ID
)
1424 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
1428 bzero (it
, sizeof *it
);
1429 it
->current
.overlay_string_index
= -1;
1430 it
->current
.dpvec_index
= -1;
1431 it
->base_face_id
= base_face_id
;
1433 /* The window in which we iterate over current_buffer: */
1434 XSETWINDOW (it
->window
, w
);
1436 it
->f
= XFRAME (w
->frame
);
1438 /* Extra space between lines (on window systems only). */
1439 if (base_face_id
== DEFAULT_FACE_ID
1440 && FRAME_WINDOW_P (it
->f
))
1442 if (NATNUMP (current_buffer
->extra_line_spacing
))
1443 it
->extra_line_spacing
= XFASTINT (current_buffer
->extra_line_spacing
);
1444 else if (it
->f
->extra_line_spacing
> 0)
1445 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
1448 /* If realized faces have been removed, e.g. because of face
1449 attribute changes of named faces, recompute them. When running
1450 in batch mode, the face cache of Vterminal_frame is null. If
1451 we happen to get called, make a dummy face cache. */
1452 if (noninteractive
&& FRAME_FACE_CACHE (it
->f
) == NULL
)
1453 init_frame_faces (it
->f
);
1454 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
1455 recompute_basic_faces (it
->f
);
1457 /* Current value of the `space-width', and 'height' properties. */
1458 it
->space_width
= Qnil
;
1459 it
->font_height
= Qnil
;
1461 /* Are control characters displayed as `^C'? */
1462 it
->ctl_arrow_p
= !NILP (current_buffer
->ctl_arrow
);
1464 /* -1 means everything between a CR and the following line end
1465 is invisible. >0 means lines indented more than this value are
1467 it
->selective
= (INTEGERP (current_buffer
->selective_display
)
1468 ? XFASTINT (current_buffer
->selective_display
)
1469 : (!NILP (current_buffer
->selective_display
)
1471 it
->selective_display_ellipsis_p
1472 = !NILP (current_buffer
->selective_display_ellipses
);
1474 /* Display table to use. */
1475 it
->dp
= window_display_table (w
);
1477 /* Are multibyte characters enabled in current_buffer? */
1478 it
->multibyte_p
= !NILP (current_buffer
->enable_multibyte_characters
);
1480 /* Non-zero if we should highlight the region. */
1482 = (!NILP (Vtransient_mark_mode
)
1483 && !NILP (current_buffer
->mark_active
)
1484 && XMARKER (current_buffer
->mark
)->buffer
!= 0);
1486 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
1487 start and end of a visible region in window IT->w. Set both to
1488 -1 to indicate no region. */
1489 if (highlight_region_p
1490 /* Maybe highlight only in selected window. */
1491 && (/* Either show region everywhere. */
1492 highlight_nonselected_windows
1493 /* Or show region in the selected window. */
1494 || w
== XWINDOW (selected_window
)
1495 /* Or show the region if we are in the mini-buffer and W is
1496 the window the mini-buffer refers to. */
1497 || (MINI_WINDOW_P (XWINDOW (selected_window
))
1498 && w
== XWINDOW (Vminibuf_scroll_window
))))
1500 int charpos
= marker_position (current_buffer
->mark
);
1501 it
->region_beg_charpos
= min (PT
, charpos
);
1502 it
->region_end_charpos
= max (PT
, charpos
);
1505 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
1507 /* Get the position at which the redisplay_end_trigger hook should
1508 be run, if it is to be run at all. */
1509 if (MARKERP (w
->redisplay_end_trigger
)
1510 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
1511 it
->redisplay_end_trigger_charpos
1512 = marker_position (w
->redisplay_end_trigger
);
1513 else if (INTEGERP (w
->redisplay_end_trigger
))
1514 it
->redisplay_end_trigger_charpos
= XINT (w
->redisplay_end_trigger
);
1516 /* Correct bogus values of tab_width. */
1517 it
->tab_width
= XINT (current_buffer
->tab_width
);
1518 if (it
->tab_width
<= 0 || it
->tab_width
> 1000)
1521 /* Are lines in the display truncated? */
1522 it
->truncate_lines_p
1523 = (base_face_id
!= DEFAULT_FACE_ID
1524 || XINT (it
->w
->hscroll
)
1525 || (truncate_partial_width_windows
1526 && !WINDOW_FULL_WIDTH_P (it
->w
))
1527 || !NILP (current_buffer
->truncate_lines
));
1529 /* Get dimensions of truncation and continuation glyphs. These are
1530 displayed as bitmaps under X, so we don't need them for such
1532 if (!FRAME_WINDOW_P (it
->f
))
1534 if (it
->truncate_lines_p
)
1536 /* We will need the truncation glyph. */
1537 xassert (it
->glyph_row
== NULL
);
1538 produce_special_glyphs (it
, IT_TRUNCATION
);
1539 it
->truncation_pixel_width
= it
->pixel_width
;
1543 /* We will need the continuation glyph. */
1544 xassert (it
->glyph_row
== NULL
);
1545 produce_special_glyphs (it
, IT_CONTINUATION
);
1546 it
->continuation_pixel_width
= it
->pixel_width
;
1549 /* Reset these values to zero becaue the produce_special_glyphs
1550 above has changed them. */
1551 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
1552 it
->phys_ascent
= it
->phys_descent
= 0;
1555 /* Set this after getting the dimensions of truncation and
1556 continuation glyphs, so that we don't produce glyphs when calling
1557 produce_special_glyphs, above. */
1558 it
->glyph_row
= row
;
1559 it
->area
= TEXT_AREA
;
1561 /* Get the dimensions of the display area. The display area
1562 consists of the visible window area plus a horizontally scrolled
1563 part to the left of the window. All x-values are relative to the
1564 start of this total display area. */
1565 if (base_face_id
!= DEFAULT_FACE_ID
)
1567 /* Mode lines, menu bar in terminal frames. */
1568 it
->first_visible_x
= 0;
1569 it
->last_visible_x
= XFASTINT (w
->width
) * CANON_X_UNIT (it
->f
);
1574 = XFASTINT (it
->w
->hscroll
) * CANON_X_UNIT (it
->f
);
1575 it
->last_visible_x
= (it
->first_visible_x
1576 + window_box_width (w
, TEXT_AREA
));
1578 /* If we truncate lines, leave room for the truncator glyph(s) at
1579 the right margin. Otherwise, leave room for the continuation
1580 glyph(s). Truncation and continuation glyphs are not inserted
1581 for window-based redisplay. */
1582 if (!FRAME_WINDOW_P (it
->f
))
1584 if (it
->truncate_lines_p
)
1585 it
->last_visible_x
-= it
->truncation_pixel_width
;
1587 it
->last_visible_x
-= it
->continuation_pixel_width
;
1590 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
1591 it
->current_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
1594 /* Leave room for a border glyph. */
1595 if (!FRAME_WINDOW_P (it
->f
)
1596 && !WINDOW_RIGHTMOST_P (it
->w
))
1597 it
->last_visible_x
-= 1;
1599 it
->last_visible_y
= window_text_bottom_y (w
);
1601 /* For mode lines and alike, arrange for the first glyph having a
1602 left box line if the face specifies a box. */
1603 if (base_face_id
!= DEFAULT_FACE_ID
)
1607 it
->face_id
= base_face_id
;
1609 /* If we have a boxed mode line, make the first character appear
1610 with a left box line. */
1611 face
= FACE_FROM_ID (it
->f
, base_face_id
);
1612 if (face
->box
!= FACE_NO_BOX
)
1613 it
->start_of_box_run_p
= 1;
1616 /* If a buffer position was specified, set the iterator there,
1617 getting overlays and face properties from that position. */
1620 it
->end_charpos
= ZV
;
1622 IT_CHARPOS (*it
) = charpos
;
1624 /* Compute byte position if not specified. */
1626 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
1628 IT_BYTEPOS (*it
) = bytepos
;
1630 /* Compute faces etc. */
1631 reseat (it
, it
->current
.pos
, 1);
1638 /* Initialize IT for the display of window W with window start POS. */
1641 start_display (it
, w
, pos
)
1644 struct text_pos pos
;
1646 int start_at_line_beg_p
;
1647 struct glyph_row
*row
;
1648 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
1651 row
= w
->desired_matrix
->rows
+ first_vpos
;
1652 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
1653 first_y
= it
->current_y
;
1655 /* If window start is not at a line start, move back to the line
1656 start. This makes sure that we take continuation lines into
1658 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
1659 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
1660 if (!start_at_line_beg_p
)
1661 reseat_at_previous_visible_line_start (it
);
1663 /* If window start is not at a line start, skip forward to POS to
1664 get the correct continuation_lines_width and current_x. */
1665 if (!start_at_line_beg_p
)
1667 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
1669 /* If lines are continued, this line may end in the middle of a
1670 multi-glyph character (e.g. a control character displayed as
1671 \003, or in the middle of an overlay string). In this case
1672 move_it_to above will not have taken us to the start of
1673 the continuation line but to the end of the continued line. */
1674 if (!it
->truncate_lines_p
)
1676 if (it
->current_x
> 0)
1678 if (it
->current
.dpvec_index
>= 0
1679 || it
->current
.overlay_string_index
>= 0)
1681 set_iterator_to_next (it
, 1);
1682 move_it_in_display_line_to (it
, -1, -1, 0);
1685 it
->continuation_lines_width
+= it
->current_x
;
1688 /* We're starting a new display line, not affected by the
1689 height of the continued line, so clear the appropriate
1690 fields in the iterator structure. */
1691 it
->max_ascent
= it
->max_descent
= 0;
1692 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
1695 it
->current_y
= first_y
;
1697 it
->current_x
= it
->hpos
= 0;
1700 #if 0 /* Don't assert the following because start_display is sometimes
1701 called intentionally with a window start that is not at a
1702 line start. Please leave this code in as a comment. */
1704 /* Window start should be on a line start, now. */
1705 xassert (it
->continuation_lines_width
1706 || IT_CHARPOS (it
) == BEGV
1707 || FETCH_BYTE (IT_BYTEPOS (it
) - 1) == '\n');
1712 /* Initialize IT for stepping through current_buffer in window W,
1713 starting at position POS that includes overlay string and display
1714 vector/ control character translation position information. */
1717 init_from_display_pos (it
, w
, pos
)
1720 struct display_pos
*pos
;
1722 /* Keep in mind: the call to reseat in init_iterator skips invisible
1723 text, so we might end up at a position different from POS. This
1724 is only a problem when POS is a row start after a newline and an
1725 overlay starts there with an after-string, and the overlay has an
1726 invisible property. Since we don't skip invisible text in
1727 display_line and elsewhere immediately after consuming the
1728 newline before the row start, such a POS will not be in a string,
1729 but the call to init_iterator below will move us to the
1731 init_iterator (it
, w
, CHARPOS (pos
->pos
), BYTEPOS (pos
->pos
),
1732 NULL
, DEFAULT_FACE_ID
);
1734 /* If position is within an overlay string, set up IT to
1735 the right overlay string. */
1736 if (pos
->overlay_string_index
>= 0)
1740 /* We already have the first chunk of overlay strings in
1741 IT->overlay_strings. Load more until the one for
1742 pos->overlay_string_index is in IT->overlay_strings. */
1743 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
1745 int n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
1746 it
->current
.overlay_string_index
= 0;
1749 load_overlay_strings (it
);
1750 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
1754 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
1755 relative_index
= (it
->current
.overlay_string_index
1756 % OVERLAY_STRING_CHUNK_SIZE
);
1757 it
->string
= it
->overlay_strings
[relative_index
];
1758 xassert (STRINGP (it
->string
));
1759 it
->current
.string_pos
= pos
->string_pos
;
1760 it
->method
= next_element_from_string
;
1762 else if (it
->current
.overlay_string_index
>= 0)
1764 /* If POS says we're already after an overlay string ending at
1765 POS, make sure to pop the iterator because it will be in
1766 front of that overlay string. When POS is ZV, we've thereby
1767 also ``processed'' overlay strings at ZV. */
1770 it
->current
.overlay_string_index
= -1;
1771 it
->method
= next_element_from_buffer
;
1772 if (CHARPOS (pos
->pos
) == ZV
)
1773 it
->overlay_strings_at_end_processed_p
= 1;
1776 if (CHARPOS (pos
->string_pos
) >= 0)
1778 /* Recorded position is not in an overlay string, but in another
1779 string. This can only be a string from a `display' property.
1780 IT should already be filled with that string. */
1781 it
->current
.string_pos
= pos
->string_pos
;
1782 xassert (STRINGP (it
->string
));
1785 /* Restore position in display vector translations or control
1786 character translations. */
1787 if (pos
->dpvec_index
>= 0)
1789 /* This fills IT->dpvec. */
1790 get_next_display_element (it
);
1791 xassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
1792 it
->current
.dpvec_index
= pos
->dpvec_index
;
1799 /* Initialize IT for stepping through current_buffer in window W
1800 starting at ROW->start. */
1803 init_to_row_start (it
, w
, row
)
1806 struct glyph_row
*row
;
1808 init_from_display_pos (it
, w
, &row
->start
);
1809 it
->continuation_lines_width
= row
->continuation_lines_width
;
1814 /* Initialize IT for stepping through current_buffer in window W
1815 starting in the line following ROW, i.e. starting at ROW->end. */
1818 init_to_row_end (it
, w
, row
)
1821 struct glyph_row
*row
;
1823 init_from_display_pos (it
, w
, &row
->end
);
1825 if (row
->continued_p
)
1826 it
->continuation_lines_width
= (row
->continuation_lines_width
1827 + row
->pixel_width
);
1834 /***********************************************************************
1836 ***********************************************************************/
1838 /* Called when IT reaches IT->stop_charpos. Handle text property and
1839 overlay changes. Set IT->stop_charpos to the next position where
1846 enum prop_handled handled
;
1847 int handle_overlay_change_p
= 1;
1851 it
->current
.dpvec_index
= -1;
1855 handled
= HANDLED_NORMALLY
;
1857 /* Call text property handlers. */
1858 for (p
= it_props
; p
->handler
; ++p
)
1860 handled
= p
->handler (it
);
1862 if (handled
== HANDLED_RECOMPUTE_PROPS
)
1864 else if (handled
== HANDLED_RETURN
)
1866 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
1867 handle_overlay_change_p
= 0;
1870 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
1872 /* Don't check for overlay strings below when set to deliver
1873 characters from a display vector. */
1874 if (it
->method
== next_element_from_display_vector
)
1875 handle_overlay_change_p
= 0;
1877 /* Handle overlay changes. */
1878 if (handle_overlay_change_p
)
1879 handled
= handle_overlay_change (it
);
1881 /* Determine where to stop next. */
1882 if (handled
== HANDLED_NORMALLY
)
1883 compute_stop_pos (it
);
1886 while (handled
== HANDLED_RECOMPUTE_PROPS
);
1890 /* Compute IT->stop_charpos from text property and overlay change
1891 information for IT's current position. */
1894 compute_stop_pos (it
)
1897 register INTERVAL iv
, next_iv
;
1898 Lisp_Object object
, limit
, position
;
1900 /* If nowhere else, stop at the end. */
1901 it
->stop_charpos
= it
->end_charpos
;
1903 if (STRINGP (it
->string
))
1905 /* Strings are usually short, so don't limit the search for
1907 object
= it
->string
;
1909 XSETFASTINT (position
, IT_STRING_CHARPOS (*it
));
1915 /* If next overlay change is in front of the current stop pos
1916 (which is IT->end_charpos), stop there. Note: value of
1917 next_overlay_change is point-max if no overlay change
1919 charpos
= next_overlay_change (IT_CHARPOS (*it
));
1920 if (charpos
< it
->stop_charpos
)
1921 it
->stop_charpos
= charpos
;
1923 /* If showing the region, we have to stop at the region
1924 start or end because the face might change there. */
1925 if (it
->region_beg_charpos
> 0)
1927 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
1928 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
1929 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
1930 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
1933 /* Set up variables for computing the stop position from text
1934 property changes. */
1935 XSETBUFFER (object
, current_buffer
);
1936 XSETFASTINT (limit
, IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
1937 XSETFASTINT (position
, IT_CHARPOS (*it
));
1941 /* Get the interval containing IT's position. Value is a null
1942 interval if there isn't such an interval. */
1943 iv
= validate_interval_range (object
, &position
, &position
, 0);
1944 if (!NULL_INTERVAL_P (iv
))
1946 Lisp_Object values_here
[LAST_PROP_IDX
];
1949 /* Get properties here. */
1950 for (p
= it_props
; p
->handler
; ++p
)
1951 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
1953 /* Look for an interval following iv that has different
1955 for (next_iv
= next_interval (iv
);
1956 (!NULL_INTERVAL_P (next_iv
)
1958 || XFASTINT (limit
) > next_iv
->position
));
1959 next_iv
= next_interval (next_iv
))
1961 for (p
= it_props
; p
->handler
; ++p
)
1963 Lisp_Object new_value
;
1965 new_value
= textget (next_iv
->plist
, *p
->name
);
1966 if (!EQ (values_here
[p
->idx
], new_value
))
1974 if (!NULL_INTERVAL_P (next_iv
))
1976 if (INTEGERP (limit
)
1977 && next_iv
->position
>= XFASTINT (limit
))
1978 /* No text property change up to limit. */
1979 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
1981 /* Text properties change in next_iv. */
1982 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
1986 xassert (STRINGP (it
->string
)
1987 || (it
->stop_charpos
>= BEGV
1988 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
1992 /* Return the position of the next overlay change after POS in
1993 current_buffer. Value is point-max if no overlay change
1994 follows. This is like `next-overlay-change' but doesn't use
1998 next_overlay_change (pos
)
2003 Lisp_Object
*overlays
;
2007 /* Get all overlays at the given position. */
2009 overlays
= (Lisp_Object
*) alloca (len
* sizeof *overlays
);
2010 noverlays
= overlays_at (pos
, 0, &overlays
, &len
, &endpos
, NULL
, 1);
2011 if (noverlays
> len
)
2014 overlays
= (Lisp_Object
*) alloca (len
* sizeof *overlays
);
2015 noverlays
= overlays_at (pos
, 0, &overlays
, &len
, &endpos
, NULL
, 1);
2018 /* If any of these overlays ends before endpos,
2019 use its ending point instead. */
2020 for (i
= 0; i
< noverlays
; ++i
)
2025 oend
= OVERLAY_END (overlays
[i
]);
2026 oendpos
= OVERLAY_POSITION (oend
);
2027 endpos
= min (endpos
, oendpos
);
2035 /***********************************************************************
2037 ***********************************************************************/
2039 /* Handle changes in the `fontified' property of the current buffer by
2040 calling hook functions from Qfontification_functions to fontify
2043 static enum prop_handled
2044 handle_fontified_prop (it
)
2047 Lisp_Object prop
, pos
;
2048 enum prop_handled handled
= HANDLED_NORMALLY
;
2050 /* Get the value of the `fontified' property at IT's current buffer
2051 position. (The `fontified' property doesn't have a special
2052 meaning in strings.) If the value is nil, call functions from
2053 Qfontification_functions. */
2054 if (!STRINGP (it
->string
)
2056 && !NILP (Vfontification_functions
)
2057 && !NILP (Vrun_hooks
)
2058 && (pos
= make_number (IT_CHARPOS (*it
)),
2059 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
2062 int count
= BINDING_STACK_SIZE ();
2065 val
= Vfontification_functions
;
2066 specbind (Qfontification_functions
, Qnil
);
2067 specbind (Qafter_change_functions
, Qnil
);
2069 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
2070 safe_call1 (val
, pos
);
2073 Lisp_Object globals
, fn
;
2074 struct gcpro gcpro1
, gcpro2
;
2077 GCPRO2 (val
, globals
);
2079 for (; CONSP (val
); val
= XCDR (val
))
2085 /* A value of t indicates this hook has a local
2086 binding; it means to run the global binding too.
2087 In a global value, t should not occur. If it
2088 does, we must ignore it to avoid an endless
2090 for (globals
= Fdefault_value (Qfontification_functions
);
2092 globals
= XCDR (globals
))
2094 fn
= XCAR (globals
);
2096 safe_call1 (fn
, pos
);
2100 safe_call1 (fn
, pos
);
2106 unbind_to (count
, Qnil
);
2108 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
2109 something. This avoids an endless loop if they failed to
2110 fontify the text for which reason ever. */
2111 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
2112 handled
= HANDLED_RECOMPUTE_PROPS
;
2120 /***********************************************************************
2122 ***********************************************************************/
2124 /* Set up iterator IT from face properties at its current position.
2125 Called from handle_stop. */
2127 static enum prop_handled
2128 handle_face_prop (it
)
2131 int new_face_id
, next_stop
;
2133 if (!STRINGP (it
->string
))
2136 = face_at_buffer_position (it
->w
,
2138 it
->region_beg_charpos
,
2139 it
->region_end_charpos
,
2142 + TEXT_PROP_DISTANCE_LIMIT
),
2145 /* Is this a start of a run of characters with box face?
2146 Caveat: this can be called for a freshly initialized
2147 iterator; face_id is -1 is this case. We know that the new
2148 face will not change until limit, i.e. if the new face has a
2149 box, all characters up to limit will have one. But, as
2150 usual, we don't know whether limit is really the end. */
2151 if (new_face_id
!= it
->face_id
)
2153 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
2155 /* If new face has a box but old face has not, this is
2156 the start of a run of characters with box, i.e. it has
2157 a shadow on the left side. The value of face_id of the
2158 iterator will be -1 if this is the initial call that gets
2159 the face. In this case, we have to look in front of IT's
2160 position and see whether there is a face != new_face_id. */
2161 it
->start_of_box_run_p
2162 = (new_face
->box
!= FACE_NO_BOX
2163 && (it
->face_id
>= 0
2164 || IT_CHARPOS (*it
) == BEG
2165 || new_face_id
!= face_before_it_pos (it
)));
2166 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
2171 int base_face_id
, bufpos
;
2173 if (it
->current
.overlay_string_index
>= 0)
2174 bufpos
= IT_CHARPOS (*it
);
2178 /* For strings from a buffer, i.e. overlay strings or strings
2179 from a `display' property, use the face at IT's current
2180 buffer position as the base face to merge with, so that
2181 overlay strings appear in the same face as surrounding
2182 text, unless they specify their own faces. */
2183 base_face_id
= underlying_face_id (it
);
2185 new_face_id
= face_at_string_position (it
->w
,
2187 IT_STRING_CHARPOS (*it
),
2189 it
->region_beg_charpos
,
2190 it
->region_end_charpos
,
2194 #if 0 /* This shouldn't be neccessary. Let's check it. */
2195 /* If IT is used to display a mode line we would really like to
2196 use the mode line face instead of the frame's default face. */
2197 if (it
->glyph_row
== MATRIX_MODE_LINE_ROW (it
->w
->desired_matrix
)
2198 && new_face_id
== DEFAULT_FACE_ID
)
2199 new_face_id
= MODE_LINE_FACE_ID
;
2202 /* Is this a start of a run of characters with box? Caveat:
2203 this can be called for a freshly allocated iterator; face_id
2204 is -1 is this case. We know that the new face will not
2205 change until the next check pos, i.e. if the new face has a
2206 box, all characters up to that position will have a
2207 box. But, as usual, we don't know whether that position
2208 is really the end. */
2209 if (new_face_id
!= it
->face_id
)
2211 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
2212 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2214 /* If new face has a box but old face hasn't, this is the
2215 start of a run of characters with box, i.e. it has a
2216 shadow on the left side. */
2217 it
->start_of_box_run_p
2218 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
2219 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
2223 it
->face_id
= new_face_id
;
2224 return HANDLED_NORMALLY
;
2228 /* Return the ID of the face ``underlying'' IT's current position,
2229 which is in a string. If the iterator is associated with a
2230 buffer, return the face at IT's current buffer position.
2231 Otherwise, use the iterator's base_face_id. */
2234 underlying_face_id (it
)
2237 int face_id
= it
->base_face_id
, i
;
2239 xassert (STRINGP (it
->string
));
2241 for (i
= it
->sp
- 1; i
>= 0; --i
)
2242 if (NILP (it
->stack
[i
].string
))
2243 face_id
= it
->stack
[i
].face_id
;
2249 /* Compute the face one character before or after the current position
2250 of IT. BEFORE_P non-zero means get the face in front of IT's
2251 position. Value is the id of the face. */
2254 face_before_or_after_it_pos (it
, before_p
)
2259 int next_check_charpos
;
2260 struct text_pos pos
;
2262 xassert (it
->s
== NULL
);
2264 if (STRINGP (it
->string
))
2266 int bufpos
, base_face_id
;
2268 /* No face change past the end of the string (for the case
2269 we are padding with spaces). No face change before the
2271 if (IT_STRING_CHARPOS (*it
) >= XSTRING (it
->string
)->size
2272 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
2275 /* Set pos to the position before or after IT's current position. */
2277 pos
= string_pos (IT_STRING_CHARPOS (*it
) - 1, it
->string
);
2279 /* For composition, we must check the character after the
2281 pos
= (it
->what
== IT_COMPOSITION
2282 ? string_pos (IT_STRING_CHARPOS (*it
) + it
->cmp_len
, it
->string
)
2283 : string_pos (IT_STRING_CHARPOS (*it
) + 1, it
->string
));
2285 if (it
->current
.overlay_string_index
>= 0)
2286 bufpos
= IT_CHARPOS (*it
);
2290 base_face_id
= underlying_face_id (it
);
2292 /* Get the face for ASCII, or unibyte. */
2293 face_id
= face_at_string_position (it
->w
,
2297 it
->region_beg_charpos
,
2298 it
->region_end_charpos
,
2299 &next_check_charpos
,
2302 /* Correct the face for charsets different from ASCII. Do it
2303 for the multibyte case only. The face returned above is
2304 suitable for unibyte text if IT->string is unibyte. */
2305 if (STRING_MULTIBYTE (it
->string
))
2307 unsigned char *p
= XSTRING (it
->string
)->data
+ BYTEPOS (pos
);
2308 int rest
= STRING_BYTES (XSTRING (it
->string
)) - BYTEPOS (pos
);
2310 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
2312 c
= string_char_and_length (p
, rest
, &len
);
2313 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
);
2318 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
2319 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
2322 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
2323 pos
= it
->current
.pos
;
2326 DEC_TEXT_POS (pos
, it
->multibyte_p
);
2329 if (it
->what
== IT_COMPOSITION
)
2330 /* For composition, we must check the position after the
2332 pos
.charpos
+= it
->cmp_len
, pos
.bytepos
+= it
->len
;
2334 INC_TEXT_POS (pos
, it
->multibyte_p
);
2337 /* Determine face for CHARSET_ASCII, or unibyte. */
2338 face_id
= face_at_buffer_position (it
->w
,
2340 it
->region_beg_charpos
,
2341 it
->region_end_charpos
,
2342 &next_check_charpos
,
2345 /* Correct the face for charsets different from ASCII. Do it
2346 for the multibyte case only. The face returned above is
2347 suitable for unibyte text if current_buffer is unibyte. */
2348 if (it
->multibyte_p
)
2350 int c
= FETCH_MULTIBYTE_CHAR (CHARPOS (pos
));
2351 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
2352 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
);
2361 /***********************************************************************
2363 ***********************************************************************/
2365 /* Set up iterator IT from invisible properties at its current
2366 position. Called from handle_stop. */
2368 static enum prop_handled
2369 handle_invisible_prop (it
)
2372 enum prop_handled handled
= HANDLED_NORMALLY
;
2374 if (STRINGP (it
->string
))
2376 extern Lisp_Object Qinvisible
;
2377 Lisp_Object prop
, end_charpos
, limit
, charpos
;
2379 /* Get the value of the invisible text property at the
2380 current position. Value will be nil if there is no such
2382 XSETFASTINT (charpos
, IT_STRING_CHARPOS (*it
));
2383 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
2386 && IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
2388 handled
= HANDLED_RECOMPUTE_PROPS
;
2390 /* Get the position at which the next change of the
2391 invisible text property can be found in IT->string.
2392 Value will be nil if the property value is the same for
2393 all the rest of IT->string. */
2394 XSETINT (limit
, XSTRING (it
->string
)->size
);
2395 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
2398 /* Text at current position is invisible. The next
2399 change in the property is at position end_charpos.
2400 Move IT's current position to that position. */
2401 if (INTEGERP (end_charpos
)
2402 && XFASTINT (end_charpos
) < XFASTINT (limit
))
2404 struct text_pos old
;
2405 old
= it
->current
.string_pos
;
2406 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
2407 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
2411 /* The rest of the string is invisible. If this is an
2412 overlay string, proceed with the next overlay string
2413 or whatever comes and return a character from there. */
2414 if (it
->current
.overlay_string_index
>= 0)
2416 next_overlay_string (it
);
2417 /* Don't check for overlay strings when we just
2418 finished processing them. */
2419 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
2423 struct Lisp_String
*s
= XSTRING (it
->string
);
2424 IT_STRING_CHARPOS (*it
) = s
->size
;
2425 IT_STRING_BYTEPOS (*it
) = STRING_BYTES (s
);
2432 int visible_p
, newpos
, next_stop
;
2433 Lisp_Object pos
, prop
;
2435 /* First of all, is there invisible text at this position? */
2436 XSETFASTINT (pos
, IT_CHARPOS (*it
));
2437 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
2439 /* If we are on invisible text, skip over it. */
2440 if (TEXT_PROP_MEANS_INVISIBLE (prop
)
2441 && IT_CHARPOS (*it
) < it
->end_charpos
)
2443 /* Record whether we have to display an ellipsis for the
2445 int display_ellipsis_p
2446 = TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (prop
);
2448 handled
= HANDLED_RECOMPUTE_PROPS
;
2450 /* Loop skipping over invisible text. The loop is left at
2451 ZV or with IT on the first char being visible again. */
2454 /* Try to skip some invisible text. Return value is the
2455 position reached which can be equal to IT's position
2456 if there is nothing invisible here. This skips both
2457 over invisible text properties and overlays with
2458 invisible property. */
2459 newpos
= skip_invisible (IT_CHARPOS (*it
),
2460 &next_stop
, ZV
, it
->window
);
2462 /* If we skipped nothing at all we weren't at invisible
2463 text in the first place. If everything to the end of
2464 the buffer was skipped, end the loop. */
2465 if (newpos
== IT_CHARPOS (*it
) || newpos
>= ZV
)
2469 /* We skipped some characters but not necessarily
2470 all there are. Check if we ended up on visible
2471 text. Fget_char_property returns the property of
2472 the char before the given position, i.e. if we
2473 get visible_p = 1, this means that the char at
2474 newpos is visible. */
2475 XSETFASTINT (pos
, newpos
);
2476 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
2477 visible_p
= !TEXT_PROP_MEANS_INVISIBLE (prop
);
2480 /* If we ended up on invisible text, proceed to
2481 skip starting with next_stop. */
2483 IT_CHARPOS (*it
) = next_stop
;
2487 /* The position newpos is now either ZV or on visible text. */
2488 IT_CHARPOS (*it
) = newpos
;
2489 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
2491 /* Maybe return `...' next for the end of the invisible text. */
2492 if (display_ellipsis_p
)
2495 && VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
2497 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
2498 it
->dpvec
= v
->contents
;
2499 it
->dpend
= v
->contents
+ v
->size
;
2503 /* Default `...'. */
2504 it
->dpvec
= default_invis_vector
;
2505 it
->dpend
= default_invis_vector
+ 3;
2508 /* The ellipsis display does not replace the display of
2509 the character at the new position. Indicate this by
2510 setting IT->dpvec_char_len to zero. */
2511 it
->dpvec_char_len
= 0;
2513 it
->current
.dpvec_index
= 0;
2514 it
->method
= next_element_from_display_vector
;
2524 /***********************************************************************
2526 ***********************************************************************/
2528 /* Set up iterator IT from `display' property at its current position.
2529 Called from handle_stop. */
2531 static enum prop_handled
2532 handle_display_prop (it
)
2535 Lisp_Object prop
, object
;
2536 struct text_pos
*position
;
2537 int space_or_image_found_p
;
2539 if (STRINGP (it
->string
))
2541 object
= it
->string
;
2542 position
= &it
->current
.string_pos
;
2547 position
= &it
->current
.pos
;
2550 /* Reset those iterator values set from display property values. */
2551 it
->font_height
= Qnil
;
2552 it
->space_width
= Qnil
;
2555 /* We don't support recursive `display' properties, i.e. string
2556 values that have a string `display' property, that have a string
2557 `display' property etc. */
2558 if (!it
->string_from_display_prop_p
)
2559 it
->area
= TEXT_AREA
;
2561 prop
= Fget_char_property (make_number (position
->charpos
),
2564 return HANDLED_NORMALLY
;
2566 space_or_image_found_p
= 0;
2568 && CONSP (XCAR (prop
))
2569 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
2571 /* A list of sub-properties. */
2572 while (CONSP (prop
))
2574 if (handle_single_display_prop (it
, XCAR (prop
), object
, position
))
2575 space_or_image_found_p
= 1;
2579 else if (VECTORP (prop
))
2582 for (i
= 0; i
< XVECTOR (prop
)->size
; ++i
)
2583 if (handle_single_display_prop (it
, XVECTOR (prop
)->contents
[i
],
2585 space_or_image_found_p
= 1;
2589 if (handle_single_display_prop (it
, prop
, object
, position
))
2590 space_or_image_found_p
= 1;
2593 return space_or_image_found_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
2597 /* Value is the position of the end of the `display' property starting
2598 at START_POS in OBJECT. */
2600 static struct text_pos
2601 display_prop_end (it
, object
, start_pos
)
2604 struct text_pos start_pos
;
2607 struct text_pos end_pos
;
2609 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
2610 Qdisplay
, object
, Qnil
);
2611 CHARPOS (end_pos
) = XFASTINT (end
);
2612 if (STRINGP (object
))
2613 compute_string_pos (&end_pos
, start_pos
, it
->string
);
2615 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
2621 /* Set up IT from a single `display' sub-property value PROP. OBJECT
2622 is the object in which the `display' property was found. *POSITION
2623 is the position at which it was found.
2625 If PROP is a `space' or `image' sub-property, set *POSITION to the
2626 end position of the `display' property.
2628 Value is non-zero if a `space' or `image' property value was found. */
2631 handle_single_display_prop (it
, prop
, object
, position
)
2635 struct text_pos
*position
;
2638 int space_or_image_found_p
= 0;
2641 /* If PROP is a list of the form `(when FORM . VALUE)', FORM is
2642 evaluated. If the result is nil, VALUE is ignored. */
2644 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
2653 if (!NILP (form
) && !EQ (form
, Qt
))
2655 struct gcpro gcpro1
;
2656 struct text_pos end_pos
, pt
;
2659 end_pos
= display_prop_end (it
, object
, *position
);
2661 /* Temporarily set point to the end position, and then evaluate
2662 the form. This makes `(eolp)' work as FORM. */
2663 if (BUFFERP (object
))
2666 BYTEPOS (pt
) = PT_BYTE
;
2667 TEMP_SET_PT_BOTH (CHARPOS (end_pos
), BYTEPOS (end_pos
));
2670 form
= safe_eval (form
);
2672 if (BUFFERP (object
))
2673 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
2681 && EQ (XCAR (prop
), Qheight
)
2682 && CONSP (XCDR (prop
)))
2684 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2687 /* `(height HEIGHT)'. */
2688 it
->font_height
= XCAR (XCDR (prop
));
2689 if (!NILP (it
->font_height
))
2691 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2692 int new_height
= -1;
2694 if (CONSP (it
->font_height
)
2695 && (EQ (XCAR (it
->font_height
), Qplus
)
2696 || EQ (XCAR (it
->font_height
), Qminus
))
2697 && CONSP (XCDR (it
->font_height
))
2698 && INTEGERP (XCAR (XCDR (it
->font_height
))))
2700 /* `(+ N)' or `(- N)' where N is an integer. */
2701 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
2702 if (EQ (XCAR (it
->font_height
), Qplus
))
2704 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
2706 else if (FUNCTIONP (it
->font_height
))
2708 /* Call function with current height as argument.
2709 Value is the new height. */
2711 height
= safe_call1 (it
->font_height
,
2712 face
->lface
[LFACE_HEIGHT_INDEX
]);
2713 if (NUMBERP (height
))
2714 new_height
= XFLOATINT (height
);
2716 else if (NUMBERP (it
->font_height
))
2718 /* Value is a multiple of the canonical char height. */
2721 face
= FACE_FROM_ID (it
->f
, DEFAULT_FACE_ID
);
2722 new_height
= (XFLOATINT (it
->font_height
)
2723 * XINT (face
->lface
[LFACE_HEIGHT_INDEX
]));
2727 /* Evaluate IT->font_height with `height' bound to the
2728 current specified height to get the new height. */
2730 int count
= BINDING_STACK_SIZE ();
2732 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
2733 value
= safe_eval (it
->font_height
);
2734 unbind_to (count
, Qnil
);
2736 if (NUMBERP (value
))
2737 new_height
= XFLOATINT (value
);
2741 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
2744 else if (CONSP (prop
)
2745 && EQ (XCAR (prop
), Qspace_width
)
2746 && CONSP (XCDR (prop
)))
2748 /* `(space_width WIDTH)'. */
2749 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2752 value
= XCAR (XCDR (prop
));
2753 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
2754 it
->space_width
= value
;
2756 else if (CONSP (prop
)
2757 && EQ (XCAR (prop
), Qraise
)
2758 && CONSP (XCDR (prop
)))
2760 /* `(raise FACTOR)'. */
2761 if (FRAME_TERMCAP_P (it
->f
) || FRAME_MSDOS_P (it
->f
))
2764 #ifdef HAVE_WINDOW_SYSTEM
2765 value
= XCAR (XCDR (prop
));
2766 if (NUMBERP (value
))
2768 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2769 it
->voffset
= - (XFLOATINT (value
)
2770 * (FONT_HEIGHT (face
->font
)));
2772 #endif /* HAVE_WINDOW_SYSTEM */
2774 else if (!it
->string_from_display_prop_p
)
2776 /* `((margin left-margin) VALUE)' or `((margin right-margin)
2777 VALUE) or `((margin nil) VALUE)' or VALUE. */
2778 Lisp_Object location
, value
;
2779 struct text_pos start_pos
;
2782 /* Characters having this form of property are not displayed, so
2783 we have to find the end of the property. */
2784 start_pos
= *position
;
2785 *position
= display_prop_end (it
, object
, start_pos
);
2788 /* Let's stop at the new position and assume that all
2789 text properties change there. */
2790 it
->stop_charpos
= position
->charpos
;
2792 location
= Qunbound
;
2793 if (CONSP (prop
) && CONSP (XCAR (prop
)))
2797 value
= XCDR (prop
);
2799 value
= XCAR (value
);
2802 if (EQ (XCAR (tem
), Qmargin
)
2803 && (tem
= XCDR (tem
),
2804 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
2806 || EQ (tem
, Qleft_margin
)
2807 || EQ (tem
, Qright_margin
))))
2811 if (EQ (location
, Qunbound
))
2817 #ifdef HAVE_WINDOW_SYSTEM
2818 if (FRAME_TERMCAP_P (it
->f
))
2819 valid_p
= STRINGP (value
);
2821 valid_p
= (STRINGP (value
)
2822 || (CONSP (value
) && EQ (XCAR (value
), Qspace
))
2823 || valid_image_p (value
));
2824 #else /* not HAVE_WINDOW_SYSTEM */
2825 valid_p
= STRINGP (value
);
2826 #endif /* not HAVE_WINDOW_SYSTEM */
2828 if ((EQ (location
, Qleft_margin
)
2829 || EQ (location
, Qright_margin
)
2833 space_or_image_found_p
= 1;
2835 /* Save current settings of IT so that we can restore them
2836 when we are finished with the glyph property value. */
2839 if (NILP (location
))
2840 it
->area
= TEXT_AREA
;
2841 else if (EQ (location
, Qleft_margin
))
2842 it
->area
= LEFT_MARGIN_AREA
;
2844 it
->area
= RIGHT_MARGIN_AREA
;
2846 if (STRINGP (value
))
2849 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
2850 it
->current
.overlay_string_index
= -1;
2851 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
2852 it
->end_charpos
= it
->string_nchars
2853 = XSTRING (it
->string
)->size
;
2854 it
->method
= next_element_from_string
;
2855 it
->stop_charpos
= 0;
2856 it
->string_from_display_prop_p
= 1;
2858 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
2860 it
->method
= next_element_from_stretch
;
2862 it
->current
.pos
= it
->position
= start_pos
;
2864 #ifdef HAVE_WINDOW_SYSTEM
2867 it
->what
= IT_IMAGE
;
2868 it
->image_id
= lookup_image (it
->f
, value
);
2869 it
->position
= start_pos
;
2870 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
2871 it
->method
= next_element_from_image
;
2873 /* Say that we haven't consumed the characters with
2874 `display' property yet. The call to pop_it in
2875 set_iterator_to_next will clean this up. */
2876 *position
= start_pos
;
2878 #endif /* HAVE_WINDOW_SYSTEM */
2881 /* Invalid property or property not supported. Restore
2882 the position to what it was before. */
2883 *position
= start_pos
;
2886 return space_or_image_found_p
;
2890 /* Check if PROP is a display sub-property value whose text should be
2891 treated as intangible. */
2894 single_display_prop_intangible_p (prop
)
2897 /* Skip over `when FORM'. */
2898 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
2909 /* Skip over `margin LOCATION'. If LOCATION is in the margins,
2910 we don't need to treat text as intangible. */
2911 if (EQ (XCAR (prop
), Qmargin
))
2919 || EQ (XCAR (prop
), Qleft_margin
)
2920 || EQ (XCAR (prop
), Qright_margin
))
2924 return CONSP (prop
) && EQ (XCAR (prop
), Qimage
);
2928 /* Check if PROP is a display property value whose text should be
2929 treated as intangible. */
2932 display_prop_intangible_p (prop
)
2936 && CONSP (XCAR (prop
))
2937 && !EQ (Qmargin
, XCAR (XCAR (prop
))))
2939 /* A list of sub-properties. */
2940 while (CONSP (prop
))
2942 if (single_display_prop_intangible_p (XCAR (prop
)))
2947 else if (VECTORP (prop
))
2949 /* A vector of sub-properties. */
2951 for (i
= 0; i
< XVECTOR (prop
)->size
; ++i
)
2952 if (single_display_prop_intangible_p (XVECTOR (prop
)->contents
[i
]))
2956 return single_display_prop_intangible_p (prop
);
2962 /***********************************************************************
2963 `composition' property
2964 ***********************************************************************/
2966 /* Set up iterator IT from `composition' property at its current
2967 position. Called from handle_stop. */
2969 static enum prop_handled
2970 handle_composition_prop (it
)
2973 Lisp_Object prop
, string
;
2974 int pos
, pos_byte
, end
;
2975 enum prop_handled handled
= HANDLED_NORMALLY
;
2977 if (STRINGP (it
->string
))
2979 pos
= IT_STRING_CHARPOS (*it
);
2980 pos_byte
= IT_STRING_BYTEPOS (*it
);
2981 string
= it
->string
;
2985 pos
= IT_CHARPOS (*it
);
2986 pos_byte
= IT_BYTEPOS (*it
);
2990 /* If there's a valid composition and point is not inside of the
2991 composition (in the case that the composition is from the current
2992 buffer), draw a glyph composed from the composition components. */
2993 if (find_composition (pos
, -1, &pos
, &end
, &prop
, string
)
2994 && COMPOSITION_VALID_P (pos
, end
, prop
)
2995 && (STRINGP (it
->string
) || (PT
<= pos
|| PT
>= end
)))
2997 int id
= get_composition_id (pos
, pos_byte
, end
- pos
, prop
, string
);
3001 it
->method
= next_element_from_composition
;
3003 it
->cmp_len
= COMPOSITION_LENGTH (prop
);
3004 /* For a terminal, draw only the first character of the
3006 it
->c
= COMPOSITION_GLYPH (composition_table
[id
], 0);
3007 it
->len
= (STRINGP (it
->string
)
3008 ? string_char_to_byte (it
->string
, end
)
3009 : CHAR_TO_BYTE (end
)) - pos_byte
;
3010 it
->stop_charpos
= end
;
3011 handled
= HANDLED_RETURN
;
3020 /***********************************************************************
3022 ***********************************************************************/
3024 /* The following structure is used to record overlay strings for
3025 later sorting in load_overlay_strings. */
3027 struct overlay_entry
3029 Lisp_Object overlay
;
3036 /* Set up iterator IT from overlay strings at its current position.
3037 Called from handle_stop. */
3039 static enum prop_handled
3040 handle_overlay_change (it
)
3043 if (!STRINGP (it
->string
) && get_overlay_strings (it
))
3044 return HANDLED_RECOMPUTE_PROPS
;
3046 return HANDLED_NORMALLY
;
3050 /* Set up the next overlay string for delivery by IT, if there is an
3051 overlay string to deliver. Called by set_iterator_to_next when the
3052 end of the current overlay string is reached. If there are more
3053 overlay strings to display, IT->string and
3054 IT->current.overlay_string_index are set appropriately here.
3055 Otherwise IT->string is set to nil. */
3058 next_overlay_string (it
)
3061 ++it
->current
.overlay_string_index
;
3062 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
3064 /* No more overlay strings. Restore IT's settings to what
3065 they were before overlay strings were processed, and
3066 continue to deliver from current_buffer. */
3068 xassert (it
->stop_charpos
>= BEGV
3069 && it
->stop_charpos
<= it
->end_charpos
);
3071 it
->current
.overlay_string_index
= -1;
3072 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
3073 it
->n_overlay_strings
= 0;
3074 it
->method
= next_element_from_buffer
;
3076 /* If we're at the end of the buffer, record that we have
3077 processed the overlay strings there already, so that
3078 next_element_from_buffer doesn't try it again. */
3079 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
3080 it
->overlay_strings_at_end_processed_p
= 1;
3084 /* There are more overlay strings to process. If
3085 IT->current.overlay_string_index has advanced to a position
3086 where we must load IT->overlay_strings with more strings, do
3088 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
3090 if (it
->current
.overlay_string_index
&& i
== 0)
3091 load_overlay_strings (it
);
3093 /* Initialize IT to deliver display elements from the overlay
3095 it
->string
= it
->overlay_strings
[i
];
3096 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
3097 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
3098 it
->method
= next_element_from_string
;
3099 it
->stop_charpos
= 0;
3106 /* Compare two overlay_entry structures E1 and E2. Used as a
3107 comparison function for qsort in load_overlay_strings. Overlay
3108 strings for the same position are sorted so that
3110 1. All after-strings come in front of before-strings, except
3111 when they come from the same overlay.
3113 2. Within after-strings, strings are sorted so that overlay strings
3114 from overlays with higher priorities come first.
3116 2. Within before-strings, strings are sorted so that overlay
3117 strings from overlays with higher priorities come last.
3119 Value is analogous to strcmp. */
3123 compare_overlay_entries (e1
, e2
)
3126 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
3127 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
3130 if (entry1
->after_string_p
!= entry2
->after_string_p
)
3132 /* Let after-strings appear in front of before-strings if
3133 they come from different overlays. */
3134 if (EQ (entry1
->overlay
, entry2
->overlay
))
3135 result
= entry1
->after_string_p
? 1 : -1;
3137 result
= entry1
->after_string_p
? -1 : 1;
3139 else if (entry1
->after_string_p
)
3140 /* After-strings sorted in order of decreasing priority. */
3141 result
= entry2
->priority
- entry1
->priority
;
3143 /* Before-strings sorted in order of increasing priority. */
3144 result
= entry1
->priority
- entry2
->priority
;
3150 /* Load the vector IT->overlay_strings with overlay strings from IT's
3151 current buffer position. Set IT->n_overlays to the total number of
3152 overlay strings found.
3154 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
3155 a time. On entry into load_overlay_strings,
3156 IT->current.overlay_string_index gives the number of overlay
3157 strings that have already been loaded by previous calls to this
3160 IT->add_overlay_start contains an additional overlay start
3161 position to consider for taking overlay strings from, if non-zero.
3162 This position comes into play when the overlay has an `invisible'
3163 property, and both before and after-strings. When we've skipped to
3164 the end of the overlay, because of its `invisible' property, we
3165 nevertheless want its before-string to appear.
3166 IT->add_overlay_start will contain the overlay start position
3169 Overlay strings are sorted so that after-string strings come in
3170 front of before-string strings. Within before and after-strings,
3171 strings are sorted by overlay priority. See also function
3172 compare_overlay_entries. */
3175 load_overlay_strings (it
)
3178 extern Lisp_Object Qafter_string
, Qbefore_string
, Qwindow
, Qpriority
;
3179 Lisp_Object ov
, overlay
, window
, str
, invisible
;
3182 int n
= 0, i
, j
, invis_p
;
3183 struct overlay_entry
*entries
3184 = (struct overlay_entry
*) alloca (size
* sizeof *entries
);
3185 int charpos
= IT_CHARPOS (*it
);
3187 /* Append the overlay string STRING of overlay OVERLAY to vector
3188 `entries' which has size `size' and currently contains `n'
3189 elements. AFTER_P non-zero means STRING is an after-string of
3191 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
3194 Lisp_Object priority; \
3198 int new_size = 2 * size; \
3199 struct overlay_entry *old = entries; \
3201 (struct overlay_entry *) alloca (new_size \
3202 * sizeof *entries); \
3203 bcopy (old, entries, size * sizeof *entries); \
3207 entries[n].string = (STRING); \
3208 entries[n].overlay = (OVERLAY); \
3209 priority = Foverlay_get ((OVERLAY), Qpriority); \
3210 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
3211 entries[n].after_string_p = (AFTER_P); \
3216 /* Process overlay before the overlay center. */
3217 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCDR (ov
))
3219 overlay
= XCAR (ov
);
3220 xassert (OVERLAYP (overlay
));
3221 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3222 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3227 /* Skip this overlay if it doesn't start or end at IT's current
3229 if (end
!= charpos
&& start
!= charpos
)
3232 /* Skip this overlay if it doesn't apply to IT->w. */
3233 window
= Foverlay_get (overlay
, Qwindow
);
3234 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
3237 /* If the text ``under'' the overlay is invisible, both before-
3238 and after-strings from this overlay are visible; start and
3239 end position are indistinguishable. */
3240 invisible
= Foverlay_get (overlay
, Qinvisible
);
3241 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
3243 /* If overlay has a non-empty before-string, record it. */
3244 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
3245 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
3246 && XSTRING (str
)->size
)
3247 RECORD_OVERLAY_STRING (overlay
, str
, 0);
3249 /* If overlay has a non-empty after-string, record it. */
3250 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
3251 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
3252 && XSTRING (str
)->size
)
3253 RECORD_OVERLAY_STRING (overlay
, str
, 1);
3256 /* Process overlays after the overlay center. */
3257 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCDR (ov
))
3259 overlay
= XCAR (ov
);
3260 xassert (OVERLAYP (overlay
));
3261 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3262 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3264 if (start
> charpos
)
3267 /* Skip this overlay if it doesn't start or end at IT's current
3269 if (end
!= charpos
&& start
!= charpos
)
3272 /* Skip this overlay if it doesn't apply to IT->w. */
3273 window
= Foverlay_get (overlay
, Qwindow
);
3274 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
3277 /* If the text ``under'' the overlay is invisible, it has a zero
3278 dimension, and both before- and after-strings apply. */
3279 invisible
= Foverlay_get (overlay
, Qinvisible
);
3280 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
3282 /* If overlay has a non-empty before-string, record it. */
3283 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
3284 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
3285 && XSTRING (str
)->size
)
3286 RECORD_OVERLAY_STRING (overlay
, str
, 0);
3288 /* If overlay has a non-empty after-string, record it. */
3289 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
3290 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
3291 && XSTRING (str
)->size
)
3292 RECORD_OVERLAY_STRING (overlay
, str
, 1);
3295 #undef RECORD_OVERLAY_STRING
3299 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
3301 /* Record the total number of strings to process. */
3302 it
->n_overlay_strings
= n
;
3304 /* IT->current.overlay_string_index is the number of overlay strings
3305 that have already been consumed by IT. Copy some of the
3306 remaining overlay strings to IT->overlay_strings. */
3308 j
= it
->current
.overlay_string_index
;
3309 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
3310 it
->overlay_strings
[i
++] = entries
[j
++].string
;
3316 /* Get the first chunk of overlay strings at IT's current buffer
3317 position. Value is non-zero if at least one overlay string was
3321 get_overlay_strings (it
)
3324 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
3325 process. This fills IT->overlay_strings with strings, and sets
3326 IT->n_overlay_strings to the total number of strings to process.
3327 IT->pos.overlay_string_index has to be set temporarily to zero
3328 because load_overlay_strings needs this; it must be set to -1
3329 when no overlay strings are found because a zero value would
3330 indicate a position in the first overlay string. */
3331 it
->current
.overlay_string_index
= 0;
3332 load_overlay_strings (it
);
3334 /* If we found overlay strings, set up IT to deliver display
3335 elements from the first one. Otherwise set up IT to deliver
3336 from current_buffer. */
3337 if (it
->n_overlay_strings
)
3339 /* Make sure we know settings in current_buffer, so that we can
3340 restore meaningful values when we're done with the overlay
3342 compute_stop_pos (it
);
3343 xassert (it
->face_id
>= 0);
3345 /* Save IT's settings. They are restored after all overlay
3346 strings have been processed. */
3347 xassert (it
->sp
== 0);
3350 /* Set up IT to deliver display elements from the first overlay
3352 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
3353 it
->stop_charpos
= 0;
3354 it
->string
= it
->overlay_strings
[0];
3355 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
3356 xassert (STRINGP (it
->string
));
3357 it
->method
= next_element_from_string
;
3362 it
->current
.overlay_string_index
= -1;
3363 it
->method
= next_element_from_buffer
;
3368 /* Value is non-zero if we found at least one overlay string. */
3369 return STRINGP (it
->string
);
3374 /***********************************************************************
3375 Saving and restoring state
3376 ***********************************************************************/
3378 /* Save current settings of IT on IT->stack. Called, for example,
3379 before setting up IT for an overlay string, to be able to restore
3380 IT's settings to what they were after the overlay string has been
3387 struct iterator_stack_entry
*p
;
3389 xassert (it
->sp
< 2);
3390 p
= it
->stack
+ it
->sp
;
3392 p
->stop_charpos
= it
->stop_charpos
;
3393 xassert (it
->face_id
>= 0);
3394 p
->face_id
= it
->face_id
;
3395 p
->string
= it
->string
;
3396 p
->pos
= it
->current
;
3397 p
->end_charpos
= it
->end_charpos
;
3398 p
->string_nchars
= it
->string_nchars
;
3400 p
->multibyte_p
= it
->multibyte_p
;
3401 p
->space_width
= it
->space_width
;
3402 p
->font_height
= it
->font_height
;
3403 p
->voffset
= it
->voffset
;
3404 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
3409 /* Restore IT's settings from IT->stack. Called, for example, when no
3410 more overlay strings must be processed, and we return to delivering
3411 display elements from a buffer, or when the end of a string from a
3412 `display' property is reached and we return to delivering display
3413 elements from an overlay string, or from a buffer. */
3419 struct iterator_stack_entry
*p
;
3421 xassert (it
->sp
> 0);
3423 p
= it
->stack
+ it
->sp
;
3424 it
->stop_charpos
= p
->stop_charpos
;
3425 it
->face_id
= p
->face_id
;
3426 it
->string
= p
->string
;
3427 it
->current
= p
->pos
;
3428 it
->end_charpos
= p
->end_charpos
;
3429 it
->string_nchars
= p
->string_nchars
;
3431 it
->multibyte_p
= p
->multibyte_p
;
3432 it
->space_width
= p
->space_width
;
3433 it
->font_height
= p
->font_height
;
3434 it
->voffset
= p
->voffset
;
3435 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
3440 /***********************************************************************
3442 ***********************************************************************/
3444 /* Set IT's current position to the previous line start. */
3447 back_to_previous_line_start (it
)
3450 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
3451 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
3455 /* Move IT to the next line start.
3457 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
3458 we skipped over part of the text (as opposed to moving the iterator
3459 continuously over the text). Otherwise, don't change the value
3462 Newlines may come from buffer text, overlay strings, or strings
3463 displayed via the `display' property. That's the reason we can't
3464 simply use find_next_newline_no_quit.
3466 Note that this function may not skip over invisible text that is so
3467 because of text properties and immediately follows a newline. If
3468 it would, function reseat_at_next_visible_line_start, when called
3469 from set_iterator_to_next, would effectively make invisible
3470 characters following a newline part of the wrong glyph row, which
3471 leads to wrong cursor motion. */
3474 forward_to_next_line_start (it
, skipped_p
)
3478 int old_selective
, newline_found_p
, n
;
3479 const int MAX_NEWLINE_DISTANCE
= 500;
3481 /* If already on a newline, just consume it to avoid unintended
3482 skipping over invisible text below. */
3483 if (it
->what
== IT_CHARACTER
&& it
->c
== '\n')
3485 set_iterator_to_next (it
, 0);
3489 /* Don't handle selective display in the following. It's (a)
3490 unnecessary because it's done by the caller, and (b) leads to an
3491 infinite recursion because next_element_from_ellipsis indirectly
3492 calls this function. */
3493 old_selective
= it
->selective
;
3496 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
3497 from buffer text. */
3498 n
= newline_found_p
= 0;
3499 while (n
< MAX_NEWLINE_DISTANCE
3500 && get_next_display_element (it
)
3501 && !newline_found_p
)
3503 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
3504 set_iterator_to_next (it
, 0);
3505 if (!STRINGP (it
->string
))
3509 /* If we didn't find a newline near enough, see if we can use a
3511 if (!newline_found_p
&& n
== MAX_NEWLINE_DISTANCE
)
3513 int start
= IT_CHARPOS (*it
);
3514 int limit
= find_next_newline_no_quit (start
, 1);
3517 xassert (!STRINGP (it
->string
));
3519 /* If there isn't any `display' property in sight, and no
3520 overlays, we can just use the position of the newline in
3522 if (it
->stop_charpos
>= limit
3523 || ((pos
= Fnext_single_property_change (make_number (start
),
3525 Qnil
, make_number (limit
)),
3527 && next_overlay_change (start
) == ZV
))
3529 IT_CHARPOS (*it
) = limit
;
3530 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
3531 *skipped_p
= newline_found_p
= 1;
3535 while (get_next_display_element (it
)
3536 && !newline_found_p
)
3538 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
3539 set_iterator_to_next (it
, 0);
3544 it
->selective
= old_selective
;
3545 return newline_found_p
;
3549 /* Set IT's current position to the previous visible line start. Skip
3550 invisible text that is so either due to text properties or due to
3551 selective display. Caution: this does not change IT->current_x and
3555 back_to_previous_visible_line_start (it
)
3560 /* Go back one newline if not on BEGV already. */
3561 if (IT_CHARPOS (*it
) > BEGV
)
3562 back_to_previous_line_start (it
);
3564 /* Move over lines that are invisible because of selective display
3565 or text properties. */
3566 while (IT_CHARPOS (*it
) > BEGV
3571 /* If selective > 0, then lines indented more than that values
3573 if (it
->selective
> 0
3574 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
3581 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
)),
3582 Qinvisible
, it
->window
);
3583 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
3587 /* Back one more newline if the current one is invisible. */
3589 back_to_previous_line_start (it
);
3592 xassert (IT_CHARPOS (*it
) >= BEGV
);
3593 xassert (IT_CHARPOS (*it
) == BEGV
3594 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
3599 /* Reseat iterator IT at the previous visible line start. Skip
3600 invisible text that is so either due to text properties or due to
3601 selective display. At the end, update IT's overlay information,
3602 face information etc. */
3605 reseat_at_previous_visible_line_start (it
)
3608 back_to_previous_visible_line_start (it
);
3609 reseat (it
, it
->current
.pos
, 1);
3614 /* Reseat iterator IT on the next visible line start in the current
3615 buffer. ON_NEWLINE_P non-zero means position IT on the newline
3616 preceding the line start. Skip over invisible text that is so
3617 because of selective display. Compute faces, overlays etc at the
3618 new position. Note that this function does not skip over text that
3619 is invisible because of text properties. */
3622 reseat_at_next_visible_line_start (it
, on_newline_p
)
3626 int newline_found_p
, skipped_p
= 0;
3628 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
3630 /* Skip over lines that are invisible because they are indented
3631 more than the value of IT->selective. */
3632 if (it
->selective
> 0)
3633 while (IT_CHARPOS (*it
) < ZV
3634 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
3636 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
3638 /* Position on the newline if that's what's requested. */
3639 if (on_newline_p
&& newline_found_p
)
3641 if (STRINGP (it
->string
))
3643 if (IT_STRING_CHARPOS (*it
) > 0)
3645 --IT_STRING_CHARPOS (*it
);
3646 --IT_STRING_BYTEPOS (*it
);
3649 else if (IT_CHARPOS (*it
) > BEGV
)
3653 reseat (it
, it
->current
.pos
, 0);
3657 reseat (it
, it
->current
.pos
, 0);
3664 /***********************************************************************
3665 Changing an iterator's position
3666 ***********************************************************************/
3668 /* Change IT's current position to POS in current_buffer. If FORCE_P
3669 is non-zero, always check for text properties at the new position.
3670 Otherwise, text properties are only looked up if POS >=
3671 IT->check_charpos of a property. */
3674 reseat (it
, pos
, force_p
)
3676 struct text_pos pos
;
3679 int original_pos
= IT_CHARPOS (*it
);
3681 reseat_1 (it
, pos
, 0);
3683 /* Determine where to check text properties. Avoid doing it
3684 where possible because text property lookup is very expensive. */
3686 || CHARPOS (pos
) > it
->stop_charpos
3687 || CHARPOS (pos
) < original_pos
)
3694 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
3695 IT->stop_pos to POS, also. */
3698 reseat_1 (it
, pos
, set_stop_p
)
3700 struct text_pos pos
;
3703 /* Don't call this function when scanning a C string. */
3704 xassert (it
->s
== NULL
);
3706 /* POS must be a reasonable value. */
3707 xassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
3709 it
->current
.pos
= it
->position
= pos
;
3710 XSETBUFFER (it
->object
, current_buffer
);
3712 it
->current
.dpvec_index
= -1;
3713 it
->current
.overlay_string_index
= -1;
3714 IT_STRING_CHARPOS (*it
) = -1;
3715 IT_STRING_BYTEPOS (*it
) = -1;
3717 it
->method
= next_element_from_buffer
;
3719 it
->face_before_selective_p
= 0;
3722 it
->stop_charpos
= CHARPOS (pos
);
3726 /* Set up IT for displaying a string, starting at CHARPOS in window W.
3727 If S is non-null, it is a C string to iterate over. Otherwise,
3728 STRING gives a Lisp string to iterate over.
3730 If PRECISION > 0, don't return more then PRECISION number of
3731 characters from the string.
3733 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
3734 characters have been returned. FIELD_WIDTH < 0 means an infinite
3737 MULTIBYTE = 0 means disable processing of multibyte characters,
3738 MULTIBYTE > 0 means enable it,
3739 MULTIBYTE < 0 means use IT->multibyte_p.
3741 IT must be initialized via a prior call to init_iterator before
3742 calling this function. */
3745 reseat_to_string (it
, s
, string
, charpos
, precision
, field_width
, multibyte
)
3750 int precision
, field_width
, multibyte
;
3752 /* No region in strings. */
3753 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
3755 /* No text property checks performed by default, but see below. */
3756 it
->stop_charpos
= -1;
3758 /* Set iterator position and end position. */
3759 bzero (&it
->current
, sizeof it
->current
);
3760 it
->current
.overlay_string_index
= -1;
3761 it
->current
.dpvec_index
= -1;
3762 xassert (charpos
>= 0);
3764 /* Use the setting of MULTIBYTE if specified. */
3766 it
->multibyte_p
= multibyte
> 0;
3770 xassert (STRINGP (string
));
3771 it
->string
= string
;
3773 it
->end_charpos
= it
->string_nchars
= XSTRING (string
)->size
;
3774 it
->method
= next_element_from_string
;
3775 it
->current
.string_pos
= string_pos (charpos
, string
);
3782 /* Note that we use IT->current.pos, not it->current.string_pos,
3783 for displaying C strings. */
3784 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
3785 if (it
->multibyte_p
)
3787 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
3788 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
3792 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
3793 it
->end_charpos
= it
->string_nchars
= strlen (s
);
3796 it
->method
= next_element_from_c_string
;
3799 /* PRECISION > 0 means don't return more than PRECISION characters
3801 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
3802 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
3804 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
3805 characters have been returned. FIELD_WIDTH == 0 means don't pad,
3806 FIELD_WIDTH < 0 means infinite field width. This is useful for
3807 padding with `-' at the end of a mode line. */
3808 if (field_width
< 0)
3809 field_width
= INFINITY
;
3810 if (field_width
> it
->end_charpos
- charpos
)
3811 it
->end_charpos
= charpos
+ field_width
;
3813 /* Use the standard display table for displaying strings. */
3814 if (DISP_TABLE_P (Vstandard_display_table
))
3815 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
3817 it
->stop_charpos
= charpos
;
3823 /***********************************************************************
3825 ***********************************************************************/
3827 /* Load IT's display element fields with information about the next
3828 display element from the current position of IT. Value is zero if
3829 end of buffer (or C string) is reached. */
3832 get_next_display_element (it
)
3835 /* Non-zero means that we found an display element. Zero means that
3836 we hit the end of what we iterate over. Performance note: the
3837 function pointer `method' used here turns out to be faster than
3838 using a sequence of if-statements. */
3839 int success_p
= (*it
->method
) (it
);
3841 if (it
->what
== IT_CHARACTER
)
3843 /* Map via display table or translate control characters.
3844 IT->c, IT->len etc. have been set to the next character by
3845 the function call above. If we have a display table, and it
3846 contains an entry for IT->c, translate it. Don't do this if
3847 IT->c itself comes from a display table, otherwise we could
3848 end up in an infinite recursion. (An alternative could be to
3849 count the recursion depth of this function and signal an
3850 error when a certain maximum depth is reached.) Is it worth
3852 if (success_p
&& it
->dpvec
== NULL
)
3857 && (dv
= DISP_CHAR_VECTOR (it
->dp
, it
->c
),
3860 struct Lisp_Vector
*v
= XVECTOR (dv
);
3862 /* Return the first character from the display table
3863 entry, if not empty. If empty, don't display the
3864 current character. */
3867 it
->dpvec_char_len
= it
->len
;
3868 it
->dpvec
= v
->contents
;
3869 it
->dpend
= v
->contents
+ v
->size
;
3870 it
->current
.dpvec_index
= 0;
3871 it
->method
= next_element_from_display_vector
;
3874 success_p
= get_next_display_element (it
);
3877 /* Translate control characters into `\003' or `^C' form.
3878 Control characters coming from a display table entry are
3879 currently not translated because we use IT->dpvec to hold
3880 the translation. This could easily be changed but I
3881 don't believe that it is worth doing.
3883 Non-printable multibyte characters are also translated
3885 else if ((it
->c
< ' '
3886 && (it
->area
!= TEXT_AREA
3887 || (it
->c
!= '\n' && it
->c
!= '\t')))
3890 || !CHAR_PRINTABLE_P (it
->c
))
3892 /* IT->c is a control character which must be displayed
3893 either as '\003' or as `^C' where the '\\' and '^'
3894 can be defined in the display table. Fill
3895 IT->ctl_chars with glyphs for what we have to
3896 display. Then, set IT->dpvec to these glyphs. */
3899 if (it
->c
< 128 && it
->ctl_arrow_p
)
3901 /* Set IT->ctl_chars[0] to the glyph for `^'. */
3903 && INTEGERP (DISP_CTRL_GLYPH (it
->dp
))
3904 && GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (it
->dp
))))
3905 g
= XINT (DISP_CTRL_GLYPH (it
->dp
));
3907 g
= FAST_MAKE_GLYPH ('^', 0);
3908 XSETINT (it
->ctl_chars
[0], g
);
3910 g
= FAST_MAKE_GLYPH (it
->c
^ 0100, 0);
3911 XSETINT (it
->ctl_chars
[1], g
);
3913 /* Set up IT->dpvec and return first character from it. */
3914 it
->dpvec_char_len
= it
->len
;
3915 it
->dpvec
= it
->ctl_chars
;
3916 it
->dpend
= it
->dpvec
+ 2;
3917 it
->current
.dpvec_index
= 0;
3918 it
->method
= next_element_from_display_vector
;
3919 get_next_display_element (it
);
3923 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
3928 /* Set IT->ctl_chars[0] to the glyph for `\\'. */
3930 && INTEGERP (DISP_ESCAPE_GLYPH (it
->dp
))
3931 && GLYPH_CHAR_VALID_P (XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
))))
3932 escape_glyph
= XFASTINT (DISP_ESCAPE_GLYPH (it
->dp
));
3934 escape_glyph
= FAST_MAKE_GLYPH ('\\', 0);
3936 if (SINGLE_BYTE_CHAR_P (it
->c
))
3937 str
[0] = it
->c
, len
= 1;
3939 len
= CHAR_STRING (it
->c
, str
);
3941 for (i
= 0; i
< len
; i
++)
3943 XSETINT (it
->ctl_chars
[i
* 4], escape_glyph
);
3944 /* Insert three more glyphs into IT->ctl_chars for
3945 the octal display of the character. */
3946 g
= FAST_MAKE_GLYPH (((str
[i
] >> 6) & 7) + '0', 0);
3947 XSETINT (it
->ctl_chars
[i
* 4 + 1], g
);
3948 g
= FAST_MAKE_GLYPH (((str
[i
] >> 3) & 7) + '0', 0);
3949 XSETINT (it
->ctl_chars
[i
* 4 + 2], g
);
3950 g
= FAST_MAKE_GLYPH ((str
[i
] & 7) + '0', 0);
3951 XSETINT (it
->ctl_chars
[i
* 4 + 3], g
);
3954 /* Set up IT->dpvec and return the first character
3956 it
->dpvec_char_len
= it
->len
;
3957 it
->dpvec
= it
->ctl_chars
;
3958 it
->dpend
= it
->dpvec
+ len
* 4;
3959 it
->current
.dpvec_index
= 0;
3960 it
->method
= next_element_from_display_vector
;
3961 get_next_display_element (it
);
3966 /* Adjust face id for a multibyte character. There are no
3967 multibyte character in unibyte text. */
3970 && FRAME_WINDOW_P (it
->f
))
3972 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3973 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->c
);
3977 /* Is this character the last one of a run of characters with
3978 box? If yes, set IT->end_of_box_run_p to 1. */
3985 it
->end_of_box_run_p
3986 = ((face_id
= face_after_it_pos (it
),
3987 face_id
!= it
->face_id
)
3988 && (face
= FACE_FROM_ID (it
->f
, face_id
),
3989 face
->box
== FACE_NO_BOX
));
3992 /* Value is 0 if end of buffer or string reached. */
3997 /* Move IT to the next display element.
3999 RESEAT_P non-zero means if called on a newline in buffer text,
4000 skip to the next visible line start.
4002 Functions get_next_display_element and set_iterator_to_next are
4003 separate because I find this arrangement easier to handle than a
4004 get_next_display_element function that also increments IT's
4005 position. The way it is we can first look at an iterator's current
4006 display element, decide whether it fits on a line, and if it does,
4007 increment the iterator position. The other way around we probably
4008 would either need a flag indicating whether the iterator has to be
4009 incremented the next time, or we would have to implement a
4010 decrement position function which would not be easy to write. */
4013 set_iterator_to_next (it
, reseat_p
)
4017 /* Reset flags indicating start and end of a sequence of characters
4018 with box. Reset them at the start of this function because
4019 moving the iterator to a new position might set them. */
4020 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
4022 if (it
->method
== next_element_from_buffer
)
4024 /* The current display element of IT is a character from
4025 current_buffer. Advance in the buffer, and maybe skip over
4026 invisible lines that are so because of selective display. */
4027 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
4028 reseat_at_next_visible_line_start (it
, 0);
4031 xassert (it
->len
!= 0);
4032 IT_BYTEPOS (*it
) += it
->len
;
4033 IT_CHARPOS (*it
) += 1;
4034 xassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
4037 else if (it
->method
== next_element_from_composition
)
4039 xassert (it
->cmp_id
>= 0 && it
->cmp_id
< n_compositions
);
4040 if (STRINGP (it
->string
))
4042 IT_STRING_BYTEPOS (*it
) += it
->len
;
4043 IT_STRING_CHARPOS (*it
) += it
->cmp_len
;
4044 it
->method
= next_element_from_string
;
4045 goto consider_string_end
;
4049 IT_BYTEPOS (*it
) += it
->len
;
4050 IT_CHARPOS (*it
) += it
->cmp_len
;
4051 it
->method
= next_element_from_buffer
;
4054 else if (it
->method
== next_element_from_c_string
)
4056 /* Current display element of IT is from a C string. */
4057 IT_BYTEPOS (*it
) += it
->len
;
4058 IT_CHARPOS (*it
) += 1;
4060 else if (it
->method
== next_element_from_display_vector
)
4062 /* Current display element of IT is from a display table entry.
4063 Advance in the display table definition. Reset it to null if
4064 end reached, and continue with characters from buffers/
4066 ++it
->current
.dpvec_index
;
4068 /* Restore face of the iterator to what they were before the
4069 display vector entry (these entries may contain faces). */
4070 it
->face_id
= it
->saved_face_id
;
4072 if (it
->dpvec
+ it
->current
.dpvec_index
== it
->dpend
)
4075 it
->method
= next_element_from_c_string
;
4076 else if (STRINGP (it
->string
))
4077 it
->method
= next_element_from_string
;
4079 it
->method
= next_element_from_buffer
;
4082 it
->current
.dpvec_index
= -1;
4084 /* Skip over characters which were displayed via IT->dpvec. */
4085 if (it
->dpvec_char_len
< 0)
4086 reseat_at_next_visible_line_start (it
, 1);
4087 else if (it
->dpvec_char_len
> 0)
4089 it
->len
= it
->dpvec_char_len
;
4090 set_iterator_to_next (it
, reseat_p
);
4094 else if (it
->method
== next_element_from_string
)
4096 /* Current display element is a character from a Lisp string. */
4097 xassert (it
->s
== NULL
&& STRINGP (it
->string
));
4098 IT_STRING_BYTEPOS (*it
) += it
->len
;
4099 IT_STRING_CHARPOS (*it
) += 1;
4101 consider_string_end
:
4103 if (it
->current
.overlay_string_index
>= 0)
4105 /* IT->string is an overlay string. Advance to the
4106 next, if there is one. */
4107 if (IT_STRING_CHARPOS (*it
) >= XSTRING (it
->string
)->size
)
4108 next_overlay_string (it
);
4112 /* IT->string is not an overlay string. If we reached
4113 its end, and there is something on IT->stack, proceed
4114 with what is on the stack. This can be either another
4115 string, this time an overlay string, or a buffer. */
4116 if (IT_STRING_CHARPOS (*it
) == XSTRING (it
->string
)->size
4120 if (!STRINGP (it
->string
))
4121 it
->method
= next_element_from_buffer
;
4125 else if (it
->method
== next_element_from_image
4126 || it
->method
== next_element_from_stretch
)
4128 /* The position etc with which we have to proceed are on
4129 the stack. The position may be at the end of a string,
4130 if the `display' property takes up the whole string. */
4133 if (STRINGP (it
->string
))
4135 it
->method
= next_element_from_string
;
4136 goto consider_string_end
;
4139 it
->method
= next_element_from_buffer
;
4142 /* There are no other methods defined, so this should be a bug. */
4145 xassert (it
->method
!= next_element_from_string
4146 || (STRINGP (it
->string
)
4147 && IT_STRING_CHARPOS (*it
) >= 0));
4151 /* Load IT's display element fields with information about the next
4152 display element which comes from a display table entry or from the
4153 result of translating a control character to one of the forms `^C'
4154 or `\003'. IT->dpvec holds the glyphs to return as characters. */
4157 next_element_from_display_vector (it
)
4161 xassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
4163 /* Remember the current face id in case glyphs specify faces.
4164 IT's face is restored in set_iterator_to_next. */
4165 it
->saved_face_id
= it
->face_id
;
4167 if (INTEGERP (*it
->dpvec
)
4168 && GLYPH_CHAR_VALID_P (XFASTINT (*it
->dpvec
)))
4173 g
= XFASTINT (it
->dpvec
[it
->current
.dpvec_index
]);
4174 it
->c
= FAST_GLYPH_CHAR (g
);
4175 it
->len
= CHAR_BYTES (it
->c
);
4177 /* The entry may contain a face id to use. Such a face id is
4178 the id of a Lisp face, not a realized face. A face id of
4179 zero means no face is specified. */
4180 lface_id
= FAST_GLYPH_FACE (g
);
4183 /* The function returns -1 if lface_id is invalid. */
4184 int face_id
= ascii_face_of_lisp_face (it
->f
, lface_id
);
4186 it
->face_id
= face_id
;
4190 /* Display table entry is invalid. Return a space. */
4191 it
->c
= ' ', it
->len
= 1;
4193 /* Don't change position and object of the iterator here. They are
4194 still the values of the character that had this display table
4195 entry or was translated, and that's what we want. */
4196 it
->what
= IT_CHARACTER
;
4201 /* Load IT with the next display element from Lisp string IT->string.
4202 IT->current.string_pos is the current position within the string.
4203 If IT->current.overlay_string_index >= 0, the Lisp string is an
4207 next_element_from_string (it
)
4210 struct text_pos position
;
4212 xassert (STRINGP (it
->string
));
4213 xassert (IT_STRING_CHARPOS (*it
) >= 0);
4214 position
= it
->current
.string_pos
;
4216 /* Time to check for invisible text? */
4217 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
4218 && IT_STRING_CHARPOS (*it
) == it
->stop_charpos
)
4222 /* Since a handler may have changed IT->method, we must
4224 return get_next_display_element (it
);
4227 if (it
->current
.overlay_string_index
>= 0)
4229 /* Get the next character from an overlay string. In overlay
4230 strings, There is no field width or padding with spaces to
4232 if (IT_STRING_CHARPOS (*it
) >= XSTRING (it
->string
)->size
)
4237 else if (STRING_MULTIBYTE (it
->string
))
4239 int remaining
= (STRING_BYTES (XSTRING (it
->string
))
4240 - IT_STRING_BYTEPOS (*it
));
4241 unsigned char *s
= (XSTRING (it
->string
)->data
4242 + IT_STRING_BYTEPOS (*it
));
4243 it
->c
= string_char_and_length (s
, remaining
, &it
->len
);
4247 it
->c
= XSTRING (it
->string
)->data
[IT_STRING_BYTEPOS (*it
)];
4253 /* Get the next character from a Lisp string that is not an
4254 overlay string. Such strings come from the mode line, for
4255 example. We may have to pad with spaces, or truncate the
4256 string. See also next_element_from_c_string. */
4257 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
4262 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
4264 /* Pad with spaces. */
4265 it
->c
= ' ', it
->len
= 1;
4266 CHARPOS (position
) = BYTEPOS (position
) = -1;
4268 else if (STRING_MULTIBYTE (it
->string
))
4270 int maxlen
= (STRING_BYTES (XSTRING (it
->string
))
4271 - IT_STRING_BYTEPOS (*it
));
4272 unsigned char *s
= (XSTRING (it
->string
)->data
4273 + IT_STRING_BYTEPOS (*it
));
4274 it
->c
= string_char_and_length (s
, maxlen
, &it
->len
);
4278 it
->c
= XSTRING (it
->string
)->data
[IT_STRING_BYTEPOS (*it
)];
4283 /* Record what we have and where it came from. Note that we store a
4284 buffer position in IT->position although it could arguably be a
4286 it
->what
= IT_CHARACTER
;
4287 it
->object
= it
->string
;
4288 it
->position
= position
;
4293 /* Load IT with next display element from C string IT->s.
4294 IT->string_nchars is the maximum number of characters to return
4295 from the string. IT->end_charpos may be greater than
4296 IT->string_nchars when this function is called, in which case we
4297 may have to return padding spaces. Value is zero if end of string
4298 reached, including padding spaces. */
4301 next_element_from_c_string (it
)
4307 it
->what
= IT_CHARACTER
;
4308 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
4311 /* IT's position can be greater IT->string_nchars in case a field
4312 width or precision has been specified when the iterator was
4314 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
4316 /* End of the game. */
4320 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
4322 /* Pad with spaces. */
4323 it
->c
= ' ', it
->len
= 1;
4324 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
4326 else if (it
->multibyte_p
)
4328 /* Implementation note: The calls to strlen apparently aren't a
4329 performance problem because there is no noticeable performance
4330 difference between Emacs running in unibyte or multibyte mode. */
4331 int maxlen
= strlen (it
->s
) - IT_BYTEPOS (*it
);
4332 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
),
4336 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
4342 /* Set up IT to return characters from an ellipsis, if appropriate.
4343 The definition of the ellipsis glyphs may come from a display table
4344 entry. This function Fills IT with the first glyph from the
4345 ellipsis if an ellipsis is to be displayed. */
4348 next_element_from_ellipsis (it
)
4351 if (it
->selective_display_ellipsis_p
)
4353 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4355 /* Use the display table definition for `...'. Invalid glyphs
4356 will be handled by the method returning elements from dpvec. */
4357 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4358 it
->dpvec_char_len
= it
->len
;
4359 it
->dpvec
= v
->contents
;
4360 it
->dpend
= v
->contents
+ v
->size
;
4361 it
->current
.dpvec_index
= 0;
4362 it
->method
= next_element_from_display_vector
;
4366 /* Use default `...' which is stored in default_invis_vector. */
4367 it
->dpvec_char_len
= it
->len
;
4368 it
->dpvec
= default_invis_vector
;
4369 it
->dpend
= default_invis_vector
+ 3;
4370 it
->current
.dpvec_index
= 0;
4371 it
->method
= next_element_from_display_vector
;
4376 /* The face at the current position may be different from the
4377 face we find after the invisible text. Remember what it
4378 was in IT->saved_face_id, and signal that it's there by
4379 setting face_before_selective_p. */
4380 it
->saved_face_id
= it
->face_id
;
4381 it
->method
= next_element_from_buffer
;
4382 reseat_at_next_visible_line_start (it
, 1);
4383 it
->face_before_selective_p
= 1;
4386 return get_next_display_element (it
);
4390 /* Deliver an image display element. The iterator IT is already
4391 filled with image information (done in handle_display_prop). Value
4396 next_element_from_image (it
)
4399 it
->what
= IT_IMAGE
;
4404 /* Fill iterator IT with next display element from a stretch glyph
4405 property. IT->object is the value of the text property. Value is
4409 next_element_from_stretch (it
)
4412 it
->what
= IT_STRETCH
;
4417 /* Load IT with the next display element from current_buffer. Value
4418 is zero if end of buffer reached. IT->stop_charpos is the next
4419 position at which to stop and check for text properties or buffer
4423 next_element_from_buffer (it
)
4428 /* Check this assumption, otherwise, we would never enter the
4429 if-statement, below. */
4430 xassert (IT_CHARPOS (*it
) >= BEGV
4431 && IT_CHARPOS (*it
) <= it
->stop_charpos
);
4433 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
4435 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
4437 int overlay_strings_follow_p
;
4439 /* End of the game, except when overlay strings follow that
4440 haven't been returned yet. */
4441 if (it
->overlay_strings_at_end_processed_p
)
4442 overlay_strings_follow_p
= 0;
4445 it
->overlay_strings_at_end_processed_p
= 1;
4446 overlay_strings_follow_p
= get_overlay_strings (it
);
4449 if (overlay_strings_follow_p
)
4450 success_p
= get_next_display_element (it
);
4454 it
->position
= it
->current
.pos
;
4461 return get_next_display_element (it
);
4466 /* No face changes, overlays etc. in sight, so just return a
4467 character from current_buffer. */
4470 /* Maybe run the redisplay end trigger hook. Performance note:
4471 This doesn't seem to cost measurable time. */
4472 if (it
->redisplay_end_trigger_charpos
4474 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
4475 run_redisplay_end_trigger_hook (it
);
4477 /* Get the next character, maybe multibyte. */
4478 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
4479 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
4481 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT_BYTE
? ZV_BYTE
: GPT_BYTE
)
4482 - IT_BYTEPOS (*it
));
4483 it
->c
= string_char_and_length (p
, maxlen
, &it
->len
);
4486 it
->c
= *p
, it
->len
= 1;
4488 /* Record what we have and where it came from. */
4489 it
->what
= IT_CHARACTER
;;
4490 it
->object
= it
->w
->buffer
;
4491 it
->position
= it
->current
.pos
;
4493 /* Normally we return the character found above, except when we
4494 really want to return an ellipsis for selective display. */
4499 /* A value of selective > 0 means hide lines indented more
4500 than that number of columns. */
4501 if (it
->selective
> 0
4502 && IT_CHARPOS (*it
) + 1 < ZV
4503 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
4504 IT_BYTEPOS (*it
) + 1,
4507 success_p
= next_element_from_ellipsis (it
);
4508 it
->dpvec_char_len
= -1;
4511 else if (it
->c
== '\r' && it
->selective
== -1)
4513 /* A value of selective == -1 means that everything from the
4514 CR to the end of the line is invisible, with maybe an
4515 ellipsis displayed for it. */
4516 success_p
= next_element_from_ellipsis (it
);
4517 it
->dpvec_char_len
= -1;
4522 /* Value is zero if end of buffer reached. */
4523 xassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
4528 /* Run the redisplay end trigger hook for IT. */
4531 run_redisplay_end_trigger_hook (it
)
4534 Lisp_Object args
[3];
4536 /* IT->glyph_row should be non-null, i.e. we should be actually
4537 displaying something, or otherwise we should not run the hook. */
4538 xassert (it
->glyph_row
);
4540 /* Set up hook arguments. */
4541 args
[0] = Qredisplay_end_trigger_functions
;
4542 args
[1] = it
->window
;
4543 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
4544 it
->redisplay_end_trigger_charpos
= 0;
4546 /* Since we are *trying* to run these functions, don't try to run
4547 them again, even if they get an error. */
4548 it
->w
->redisplay_end_trigger
= Qnil
;
4549 Frun_hook_with_args (3, args
);
4551 /* Notice if it changed the face of the character we are on. */
4552 handle_face_prop (it
);
4556 /* Deliver a composition display element. The iterator IT is already
4557 filled with composition information (done in
4558 handle_composition_prop). Value is always 1. */
4561 next_element_from_composition (it
)
4564 it
->what
= IT_COMPOSITION
;
4565 it
->position
= (STRINGP (it
->string
)
4566 ? it
->current
.string_pos
4573 /***********************************************************************
4574 Moving an iterator without producing glyphs
4575 ***********************************************************************/
4577 /* Move iterator IT to a specified buffer or X position within one
4578 line on the display without producing glyphs.
4580 Begin to skip at IT's current position. Skip to TO_CHARPOS or TO_X
4581 whichever is reached first.
4583 TO_CHARPOS <= 0 means no TO_CHARPOS is specified.
4585 TO_X < 0 means that no TO_X is specified. TO_X is normally a value
4586 0 <= TO_X <= IT->last_visible_x. This means in particular, that
4587 TO_X includes the amount by which a window is horizontally
4592 MOVE_POS_MATCH_OR_ZV
4593 - when TO_POS or ZV was reached.
4596 -when TO_X was reached before TO_POS or ZV were reached.
4599 - when we reached the end of the display area and the line must
4603 - when we reached the end of the display area and the line is
4607 - when we stopped at a line end, i.e. a newline or a CR and selective
4610 static enum move_it_result
4611 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
)
4613 int to_charpos
, to_x
, op
;
4615 enum move_it_result result
= MOVE_UNDEFINED
;
4616 struct glyph_row
*saved_glyph_row
;
4618 /* Don't produce glyphs in produce_glyphs. */
4619 saved_glyph_row
= it
->glyph_row
;
4620 it
->glyph_row
= NULL
;
4624 int x
, i
, ascent
= 0, descent
= 0;
4626 /* Stop when ZV or TO_CHARPOS reached. */
4627 if (!get_next_display_element (it
)
4628 || ((op
& MOVE_TO_POS
) != 0
4629 && BUFFERP (it
->object
)
4630 && IT_CHARPOS (*it
) >= to_charpos
))
4632 result
= MOVE_POS_MATCH_OR_ZV
;
4636 /* The call to produce_glyphs will get the metrics of the
4637 display element IT is loaded with. We record in x the
4638 x-position before this display element in case it does not
4642 /* Remember the line height so far in case the next element doesn't
4644 if (!it
->truncate_lines_p
)
4646 ascent
= it
->max_ascent
;
4647 descent
= it
->max_descent
;
4650 PRODUCE_GLYPHS (it
);
4652 if (it
->area
!= TEXT_AREA
)
4654 set_iterator_to_next (it
, 1);
4658 /* The number of glyphs we get back in IT->nglyphs will normally
4659 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
4660 character on a terminal frame, or (iii) a line end. For the
4661 second case, IT->nglyphs - 1 padding glyphs will be present
4662 (on X frames, there is only one glyph produced for a
4663 composite character.
4665 The behavior implemented below means, for continuation lines,
4666 that as many spaces of a TAB as fit on the current line are
4667 displayed there. For terminal frames, as many glyphs of a
4668 multi-glyph character are displayed in the current line, too.
4669 This is what the old redisplay code did, and we keep it that
4670 way. Under X, the whole shape of a complex character must
4671 fit on the line or it will be completely displayed in the
4674 Note that both for tabs and padding glyphs, all glyphs have
4678 /* More than one glyph or glyph doesn't fit on line. All
4679 glyphs have the same width. */
4680 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
4683 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
4685 new_x
= x
+ single_glyph_width
;
4687 /* We want to leave anything reaching TO_X to the caller. */
4688 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
4691 result
= MOVE_X_REACHED
;
4694 else if (/* Lines are continued. */
4695 !it
->truncate_lines_p
4696 && (/* And glyph doesn't fit on the line. */
4697 new_x
> it
->last_visible_x
4698 /* Or it fits exactly and we're on a window
4700 || (new_x
== it
->last_visible_x
4701 && FRAME_WINDOW_P (it
->f
))))
4703 if (/* IT->hpos == 0 means the very first glyph
4704 doesn't fit on the line, e.g. a wide image. */
4706 || (new_x
== it
->last_visible_x
4707 && FRAME_WINDOW_P (it
->f
)))
4710 it
->current_x
= new_x
;
4711 if (i
== it
->nglyphs
- 1)
4712 set_iterator_to_next (it
, 1);
4717 it
->max_ascent
= ascent
;
4718 it
->max_descent
= descent
;
4721 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
4723 result
= MOVE_LINE_CONTINUED
;
4726 else if (new_x
> it
->first_visible_x
)
4728 /* Glyph is visible. Increment number of glyphs that
4729 would be displayed. */
4734 /* Glyph is completely off the left margin of the display
4735 area. Nothing to do. */
4739 if (result
!= MOVE_UNDEFINED
)
4742 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
4744 /* Stop when TO_X specified and reached. This check is
4745 necessary here because of lines consisting of a line end,
4746 only. The line end will not produce any glyphs and we
4747 would never get MOVE_X_REACHED. */
4748 xassert (it
->nglyphs
== 0);
4749 result
= MOVE_X_REACHED
;
4753 /* Is this a line end? If yes, we're done. */
4754 if (ITERATOR_AT_END_OF_LINE_P (it
))
4756 result
= MOVE_NEWLINE_OR_CR
;
4760 /* The current display element has been consumed. Advance
4762 set_iterator_to_next (it
, 1);
4764 /* Stop if lines are truncated and IT's current x-position is
4765 past the right edge of the window now. */
4766 if (it
->truncate_lines_p
4767 && it
->current_x
>= it
->last_visible_x
)
4769 result
= MOVE_LINE_TRUNCATED
;
4774 /* Restore the iterator settings altered at the beginning of this
4776 it
->glyph_row
= saved_glyph_row
;
4781 /* Move IT forward to a specified buffer position TO_CHARPOS, TO_X,
4782 TO_Y, TO_VPOS. OP is a bit-mask that specifies where to stop. See
4783 the description of enum move_operation_enum.
4785 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
4786 screen line, this function will set IT to the next position >
4790 move_it_to (it
, to_charpos
, to_x
, to_y
, to_vpos
, op
)
4792 int to_charpos
, to_x
, to_y
, to_vpos
;
4795 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
4801 if (op
& MOVE_TO_VPOS
)
4803 /* If no TO_CHARPOS and no TO_X specified, stop at the
4804 start of the line TO_VPOS. */
4805 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
4807 if (it
->vpos
== to_vpos
)
4813 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
4817 /* TO_VPOS >= 0 means stop at TO_X in the line at
4818 TO_VPOS, or at TO_POS, whichever comes first. */
4819 if (it
->vpos
== to_vpos
)
4825 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
4827 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
4832 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
4834 /* We have reached TO_X but not in the line we want. */
4835 skip
= move_it_in_display_line_to (it
, to_charpos
,
4837 if (skip
== MOVE_POS_MATCH_OR_ZV
)
4845 else if (op
& MOVE_TO_Y
)
4847 struct it it_backup
;
4849 /* TO_Y specified means stop at TO_X in the line containing
4850 TO_Y---or at TO_CHARPOS if this is reached first. The
4851 problem is that we can't really tell whether the line
4852 contains TO_Y before we have completely scanned it, and
4853 this may skip past TO_X. What we do is to first scan to
4856 If TO_X is not specified, use a TO_X of zero. The reason
4857 is to make the outcome of this function more predictable.
4858 If we didn't use TO_X == 0, we would stop at the end of
4859 the line which is probably not what a caller would expect
4861 skip
= move_it_in_display_line_to (it
, to_charpos
,
4865 | (op
& MOVE_TO_POS
)));
4867 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
4868 if (skip
== MOVE_POS_MATCH_OR_ZV
)
4874 /* If TO_X was reached, we would like to know whether TO_Y
4875 is in the line. This can only be said if we know the
4876 total line height which requires us to scan the rest of
4878 if (skip
== MOVE_X_REACHED
)
4881 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
4882 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
4884 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
4887 /* Now, decide whether TO_Y is in this line. */
4888 line_height
= it
->max_ascent
+ it
->max_descent
;
4889 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
4891 if (to_y
>= it
->current_y
4892 && to_y
< it
->current_y
+ line_height
)
4894 if (skip
== MOVE_X_REACHED
)
4895 /* If TO_Y is in this line and TO_X was reached above,
4896 we scanned too far. We have to restore IT's settings
4897 to the ones before skipping. */
4901 else if (skip
== MOVE_X_REACHED
)
4904 if (skip
== MOVE_POS_MATCH_OR_ZV
)
4912 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
4916 case MOVE_POS_MATCH_OR_ZV
:
4920 case MOVE_NEWLINE_OR_CR
:
4921 set_iterator_to_next (it
, 1);
4922 it
->continuation_lines_width
= 0;
4925 case MOVE_LINE_TRUNCATED
:
4926 it
->continuation_lines_width
= 0;
4927 reseat_at_next_visible_line_start (it
, 0);
4928 if ((op
& MOVE_TO_POS
) != 0
4929 && IT_CHARPOS (*it
) > to_charpos
)
4936 case MOVE_LINE_CONTINUED
:
4937 it
->continuation_lines_width
+= it
->current_x
;
4944 /* Reset/increment for the next run. */
4945 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
4946 it
->current_x
= it
->hpos
= 0;
4947 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
4949 last_height
= it
->max_ascent
+ it
->max_descent
;
4950 last_max_ascent
= it
->max_ascent
;
4951 it
->max_ascent
= it
->max_descent
= 0;
4956 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
4960 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
4962 If DY > 0, move IT backward at least that many pixels. DY = 0
4963 means move IT backward to the preceding line start or BEGV. This
4964 function may move over more than DY pixels if IT->current_y - DY
4965 ends up in the middle of a line; in this case IT->current_y will be
4966 set to the top of the line moved to. */
4969 move_it_vertically_backward (it
, dy
)
4973 int nlines
, h
, line_height
;
4975 int start_pos
= IT_CHARPOS (*it
);
4979 /* Estimate how many newlines we must move back. */
4980 nlines
= max (1, dy
/ CANON_Y_UNIT (it
->f
));
4982 /* Set the iterator's position that many lines back. */
4983 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
4984 back_to_previous_visible_line_start (it
);
4986 /* Reseat the iterator here. When moving backward, we don't want
4987 reseat to skip forward over invisible text, set up the iterator
4988 to deliver from overlay strings at the new position etc. So,
4989 use reseat_1 here. */
4990 reseat_1 (it
, it
->current
.pos
, 1);
4992 /* We are now surely at a line start. */
4993 it
->current_x
= it
->hpos
= 0;
4995 /* Move forward and see what y-distance we moved. First move to the
4996 start of the next line so that we get its height. We need this
4997 height to be able to tell whether we reached the specified
5000 it2
.max_ascent
= it2
.max_descent
= 0;
5001 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
5002 MOVE_TO_POS
| MOVE_TO_VPOS
);
5003 xassert (IT_CHARPOS (*it
) >= BEGV
);
5004 line_height
= it2
.max_ascent
+ it2
.max_descent
;
5006 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
5007 xassert (IT_CHARPOS (*it
) >= BEGV
);
5008 h
= it2
.current_y
- it
->current_y
;
5009 nlines
= it2
.vpos
- it
->vpos
;
5011 /* Correct IT's y and vpos position. */
5017 /* DY == 0 means move to the start of the screen line. The
5018 value of nlines is > 0 if continuation lines were involved. */
5020 move_it_by_lines (it
, nlines
, 1);
5021 xassert (IT_CHARPOS (*it
) <= start_pos
);
5025 /* The y-position we try to reach. Note that h has been
5026 subtracted in front of the if-statement. */
5027 int target_y
= it
->current_y
+ h
- dy
;
5029 /* If we did not reach target_y, try to move further backward if
5030 we can. If we moved too far backward, try to move forward. */
5031 if (target_y
< it
->current_y
5032 && IT_CHARPOS (*it
) > BEGV
)
5034 move_it_vertically (it
, target_y
- it
->current_y
);
5035 xassert (IT_CHARPOS (*it
) >= BEGV
);
5037 else if (target_y
>= it
->current_y
+ line_height
5038 && IT_CHARPOS (*it
) < ZV
)
5040 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
5041 xassert (IT_CHARPOS (*it
) >= BEGV
);
5047 /* Move IT by a specified amount of pixel lines DY. DY negative means
5048 move backwards. DY = 0 means move to start of screen line. At the
5049 end, IT will be on the start of a screen line. */
5052 move_it_vertically (it
, dy
)
5057 move_it_vertically_backward (it
, -dy
);
5060 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
5061 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
5062 MOVE_TO_POS
| MOVE_TO_Y
);
5063 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
5065 /* If buffer ends in ZV without a newline, move to the start of
5066 the line to satisfy the post-condition. */
5067 if (IT_CHARPOS (*it
) == ZV
5068 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
5069 move_it_by_lines (it
, 0, 0);
5074 #if 0 /* Currently not used. */
5076 /* Return non-zero if some text between buffer positions START_CHARPOS
5077 and END_CHARPOS is invisible. IT->window is the window for text
5081 invisible_text_between_p (it
, start_charpos
, end_charpos
)
5083 int start_charpos
, end_charpos
;
5085 Lisp_Object prop
, limit
;
5086 int invisible_found_p
;
5088 xassert (it
!= NULL
&& start_charpos
<= end_charpos
);
5090 /* Is text at START invisible? */
5091 prop
= Fget_char_property (make_number (start_charpos
), Qinvisible
,
5093 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
5094 invisible_found_p
= 1;
5097 limit
= Fnext_single_char_property_change (make_number (start_charpos
),
5099 make_number (end_charpos
));
5100 invisible_found_p
= XFASTINT (limit
) < end_charpos
;
5103 return invisible_found_p
;
5109 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
5110 negative means move up. DVPOS == 0 means move to the start of the
5111 screen line. NEED_Y_P non-zero means calculate IT->current_y. If
5112 NEED_Y_P is zero, IT->current_y will be left unchanged.
5114 Further optimization ideas: If we would know that IT->f doesn't use
5115 a face with proportional font, we could be faster for
5116 truncate-lines nil. */
5119 move_it_by_lines (it
, dvpos
, need_y_p
)
5121 int dvpos
, need_y_p
;
5123 struct position pos
;
5125 if (!FRAME_WINDOW_P (it
->f
))
5127 struct text_pos textpos
;
5129 /* We can use vmotion on frames without proportional fonts. */
5130 pos
= *vmotion (IT_CHARPOS (*it
), dvpos
, it
->w
);
5131 SET_TEXT_POS (textpos
, pos
.bufpos
, pos
.bytepos
);
5132 reseat (it
, textpos
, 1);
5133 it
->vpos
+= pos
.vpos
;
5134 it
->current_y
+= pos
.vpos
;
5136 else if (dvpos
== 0)
5138 /* DVPOS == 0 means move to the start of the screen line. */
5139 move_it_vertically_backward (it
, 0);
5140 xassert (it
->current_x
== 0 && it
->hpos
== 0);
5143 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
5147 int start_charpos
, i
;
5149 /* Go back -DVPOS visible lines and reseat the iterator there. */
5150 start_charpos
= IT_CHARPOS (*it
);
5151 for (i
= -dvpos
; i
&& IT_CHARPOS (*it
) > BEGV
; --i
)
5152 back_to_previous_visible_line_start (it
);
5153 reseat (it
, it
->current
.pos
, 1);
5154 it
->current_x
= it
->hpos
= 0;
5156 /* Above call may have moved too far if continuation lines
5157 are involved. Scan forward and see if it did. */
5159 it2
.vpos
= it2
.current_y
= 0;
5160 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
5161 it
->vpos
-= it2
.vpos
;
5162 it
->current_y
-= it2
.current_y
;
5163 it
->current_x
= it
->hpos
= 0;
5165 /* If we moved too far, move IT some lines forward. */
5166 if (it2
.vpos
> -dvpos
)
5168 int delta
= it2
.vpos
+ dvpos
;
5169 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
5176 /***********************************************************************
5178 ***********************************************************************/
5181 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
5185 add_to_log (format
, arg1
, arg2
)
5187 Lisp_Object arg1
, arg2
;
5189 Lisp_Object args
[3];
5190 Lisp_Object msg
, fmt
;
5193 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5196 GCPRO4 (fmt
, msg
, arg1
, arg2
);
5198 args
[0] = fmt
= build_string (format
);
5201 msg
= Fformat (3, args
);
5203 len
= STRING_BYTES (XSTRING (msg
)) + 1;
5204 buffer
= (char *) alloca (len
);
5205 strcpy (buffer
, XSTRING (msg
)->data
);
5207 message_dolog (buffer
, len
- 1, 1, 0);
5212 /* Output a newline in the *Messages* buffer if "needs" one. */
5215 message_log_maybe_newline ()
5217 if (message_log_need_newline
)
5218 message_dolog ("", 0, 1, 0);
5222 /* Add a string M of length LEN to the message log, optionally
5223 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
5224 nonzero, means interpret the contents of M as multibyte. This
5225 function calls low-level routines in order to bypass text property
5226 hooks, etc. which might not be safe to run. */
5229 message_dolog (m
, len
, nlflag
, multibyte
)
5231 int len
, nlflag
, multibyte
;
5233 if (!NILP (Vmessage_log_max
))
5235 struct buffer
*oldbuf
;
5236 Lisp_Object oldpoint
, oldbegv
, oldzv
;
5237 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5238 int point_at_end
= 0;
5240 Lisp_Object old_deactivate_mark
, tem
;
5241 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5243 old_deactivate_mark
= Vdeactivate_mark
;
5244 oldbuf
= current_buffer
;
5245 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
5246 current_buffer
->undo_list
= Qt
;
5248 oldpoint
= Fpoint_marker ();
5249 oldbegv
= Fpoint_min_marker ();
5250 oldzv
= Fpoint_max_marker ();
5251 GCPRO4 (oldpoint
, oldbegv
, oldzv
, old_deactivate_mark
);
5259 BEGV_BYTE
= BEG_BYTE
;
5262 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
5264 /* Insert the string--maybe converting multibyte to single byte
5265 or vice versa, so that all the text fits the buffer. */
5267 && NILP (current_buffer
->enable_multibyte_characters
))
5270 unsigned char work
[1];
5272 /* Convert a multibyte string to single-byte
5273 for the *Message* buffer. */
5274 for (i
= 0; i
< len
; i
+= nbytes
)
5276 c
= string_char_and_length (m
+ i
, len
- i
, &nbytes
);
5277 work
[0] = (SINGLE_BYTE_CHAR_P (c
)
5279 : multibyte_char_to_unibyte (c
, Qnil
));
5280 insert_1_both (work
, 1, 1, 1, 0, 0);
5283 else if (! multibyte
5284 && ! NILP (current_buffer
->enable_multibyte_characters
))
5287 unsigned char *msg
= (unsigned char *) m
;
5288 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
5289 /* Convert a single-byte string to multibyte
5290 for the *Message* buffer. */
5291 for (i
= 0; i
< len
; i
++)
5293 c
= unibyte_char_to_multibyte (msg
[i
]);
5294 nbytes
= CHAR_STRING (c
, str
);
5295 insert_1_both (str
, 1, nbytes
, 1, 0, 0);
5299 insert_1 (m
, len
, 1, 0, 0);
5303 int this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
, dup
;
5304 insert_1 ("\n", 1, 1, 0, 0);
5306 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
5308 this_bol_byte
= PT_BYTE
;
5312 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
5314 prev_bol_byte
= PT_BYTE
;
5316 dup
= message_log_check_duplicate (prev_bol
, prev_bol_byte
,
5317 this_bol
, this_bol_byte
);
5320 del_range_both (prev_bol
, prev_bol_byte
,
5321 this_bol
, this_bol_byte
, 0);
5327 /* If you change this format, don't forget to also
5328 change message_log_check_duplicate. */
5329 sprintf (dupstr
, " [%d times]", dup
);
5330 duplen
= strlen (dupstr
);
5331 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
5332 insert_1 (dupstr
, duplen
, 1, 0, 1);
5337 if (NATNUMP (Vmessage_log_max
))
5339 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
5340 -XFASTINT (Vmessage_log_max
) - 1, 0);
5341 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
5344 BEGV
= XMARKER (oldbegv
)->charpos
;
5345 BEGV_BYTE
= marker_byte_position (oldbegv
);
5354 ZV
= XMARKER (oldzv
)->charpos
;
5355 ZV_BYTE
= marker_byte_position (oldzv
);
5359 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
5361 /* We can't do Fgoto_char (oldpoint) because it will run some
5363 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
5364 XMARKER (oldpoint
)->bytepos
);
5367 free_marker (oldpoint
);
5368 free_marker (oldbegv
);
5369 free_marker (oldzv
);
5371 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
5372 set_buffer_internal (oldbuf
);
5374 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5375 message_log_need_newline
= !nlflag
;
5376 Vdeactivate_mark
= old_deactivate_mark
;
5381 /* We are at the end of the buffer after just having inserted a newline.
5382 (Note: We depend on the fact we won't be crossing the gap.)
5383 Check to see if the most recent message looks a lot like the previous one.
5384 Return 0 if different, 1 if the new one should just replace it, or a
5385 value N > 1 if we should also append " [N times]". */
5388 message_log_check_duplicate (prev_bol
, prev_bol_byte
, this_bol
, this_bol_byte
)
5389 int prev_bol
, this_bol
;
5390 int prev_bol_byte
, this_bol_byte
;
5393 int len
= Z_BYTE
- 1 - this_bol_byte
;
5395 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
5396 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
5398 for (i
= 0; i
< len
; i
++)
5400 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
5408 if (*p1
++ == ' ' && *p1
++ == '[')
5411 while (*p1
>= '0' && *p1
<= '9')
5412 n
= n
* 10 + *p1
++ - '0';
5413 if (strncmp (p1
, " times]\n", 8) == 0)
5420 /* Display an echo area message M with a specified length of LEN
5421 chars. The string may include null characters. If M is 0, clear
5422 out any existing message, and let the mini-buffer text show through.
5424 The buffer M must continue to exist until after the echo area gets
5425 cleared or some other message gets displayed there. This means do
5426 not pass text that is stored in a Lisp string; do not pass text in
5427 a buffer that was alloca'd. */
5430 message2 (m
, len
, multibyte
)
5435 /* First flush out any partial line written with print. */
5436 message_log_maybe_newline ();
5438 message_dolog (m
, len
, 1, multibyte
);
5439 message2_nolog (m
, len
, multibyte
);
5443 /* The non-logging counterpart of message2. */
5446 message2_nolog (m
, len
, multibyte
)
5450 struct frame
*sf
= SELECTED_FRAME ();
5451 message_enable_multibyte
= multibyte
;
5455 if (noninteractive_need_newline
)
5456 putc ('\n', stderr
);
5457 noninteractive_need_newline
= 0;
5459 fwrite (m
, len
, 1, stderr
);
5460 if (cursor_in_echo_area
== 0)
5461 fprintf (stderr
, "\n");
5464 /* A null message buffer means that the frame hasn't really been
5465 initialized yet. Error messages get reported properly by
5466 cmd_error, so this must be just an informative message; toss it. */
5467 else if (INTERACTIVE
5468 && sf
->glyphs_initialized_p
5469 && FRAME_MESSAGE_BUF (sf
))
5471 Lisp_Object mini_window
;
5474 /* Get the frame containing the mini-buffer
5475 that the selected frame is using. */
5476 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
5477 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
5479 FRAME_SAMPLE_VISIBILITY (f
);
5480 if (FRAME_VISIBLE_P (sf
)
5481 && ! FRAME_VISIBLE_P (f
))
5482 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
5486 set_message (m
, Qnil
, len
, multibyte
);
5487 if (minibuffer_auto_raise
)
5488 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
5491 clear_message (1, 1);
5493 do_pending_window_change (0);
5494 echo_area_display (1);
5495 do_pending_window_change (0);
5496 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
5497 (*frame_up_to_date_hook
) (f
);
5502 /* Display an echo area message M with a specified length of NBYTES
5503 bytes. The string may include null characters. If M is not a
5504 string, clear out any existing message, and let the mini-buffer
5505 text show through. */
5508 message3 (m
, nbytes
, multibyte
)
5513 struct gcpro gcpro1
;
5517 /* First flush out any partial line written with print. */
5518 message_log_maybe_newline ();
5520 message_dolog (XSTRING (m
)->data
, nbytes
, 1, multibyte
);
5521 message3_nolog (m
, nbytes
, multibyte
);
5527 /* The non-logging version of message3. */
5530 message3_nolog (m
, nbytes
, multibyte
)
5532 int nbytes
, multibyte
;
5534 struct frame
*sf
= SELECTED_FRAME ();
5535 message_enable_multibyte
= multibyte
;
5539 if (noninteractive_need_newline
)
5540 putc ('\n', stderr
);
5541 noninteractive_need_newline
= 0;
5543 fwrite (XSTRING (m
)->data
, nbytes
, 1, stderr
);
5544 if (cursor_in_echo_area
== 0)
5545 fprintf (stderr
, "\n");
5548 /* A null message buffer means that the frame hasn't really been
5549 initialized yet. Error messages get reported properly by
5550 cmd_error, so this must be just an informative message; toss it. */
5551 else if (INTERACTIVE
5552 && sf
->glyphs_initialized_p
5553 && FRAME_MESSAGE_BUF (sf
))
5555 Lisp_Object mini_window
;
5559 /* Get the frame containing the mini-buffer
5560 that the selected frame is using. */
5561 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
5562 frame
= XWINDOW (mini_window
)->frame
;
5565 FRAME_SAMPLE_VISIBILITY (f
);
5566 if (FRAME_VISIBLE_P (sf
)
5567 && !FRAME_VISIBLE_P (f
))
5568 Fmake_frame_visible (frame
);
5570 if (STRINGP (m
) && XSTRING (m
)->size
)
5572 set_message (NULL
, m
, nbytes
, multibyte
);
5573 if (minibuffer_auto_raise
)
5574 Fraise_frame (frame
);
5577 clear_message (1, 1);
5579 do_pending_window_change (0);
5580 echo_area_display (1);
5581 do_pending_window_change (0);
5582 if (frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
5583 (*frame_up_to_date_hook
) (f
);
5588 /* Display a null-terminated echo area message M. If M is 0, clear
5589 out any existing message, and let the mini-buffer text show through.
5591 The buffer M must continue to exist until after the echo area gets
5592 cleared or some other message gets displayed there. Do not pass
5593 text that is stored in a Lisp string. Do not pass text in a buffer
5594 that was alloca'd. */
5600 message2 (m
, (m
? strlen (m
) : 0), 0);
5604 /* The non-logging counterpart of message1. */
5610 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
5613 /* Display a message M which contains a single %s
5614 which gets replaced with STRING. */
5617 message_with_string (m
, string
, log
)
5626 if (noninteractive_need_newline
)
5627 putc ('\n', stderr
);
5628 noninteractive_need_newline
= 0;
5629 fprintf (stderr
, m
, XSTRING (string
)->data
);
5630 if (cursor_in_echo_area
== 0)
5631 fprintf (stderr
, "\n");
5635 else if (INTERACTIVE
)
5637 /* The frame whose minibuffer we're going to display the message on.
5638 It may be larger than the selected frame, so we need
5639 to use its buffer, not the selected frame's buffer. */
5640 Lisp_Object mini_window
;
5641 struct frame
*f
, *sf
= SELECTED_FRAME ();
5643 /* Get the frame containing the minibuffer
5644 that the selected frame is using. */
5645 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
5646 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
5648 /* A null message buffer means that the frame hasn't really been
5649 initialized yet. Error messages get reported properly by
5650 cmd_error, so this must be just an informative message; toss it. */
5651 if (FRAME_MESSAGE_BUF (f
))
5655 a
[0] = (char *) XSTRING (string
)->data
;
5657 len
= doprnt (FRAME_MESSAGE_BUF (f
),
5658 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
5661 message2 (FRAME_MESSAGE_BUF (f
), len
,
5662 STRING_MULTIBYTE (string
));
5664 message2_nolog (FRAME_MESSAGE_BUF (f
), len
,
5665 STRING_MULTIBYTE (string
));
5667 /* Print should start at the beginning of the message
5668 buffer next time. */
5669 message_buf_print
= 0;
5675 /* Dump an informative message to the minibuf. If M is 0, clear out
5676 any existing message, and let the mini-buffer text show through. */
5680 message (m
, a1
, a2
, a3
)
5682 EMACS_INT a1
, a2
, a3
;
5688 if (noninteractive_need_newline
)
5689 putc ('\n', stderr
);
5690 noninteractive_need_newline
= 0;
5691 fprintf (stderr
, m
, a1
, a2
, a3
);
5692 if (cursor_in_echo_area
== 0)
5693 fprintf (stderr
, "\n");
5697 else if (INTERACTIVE
)
5699 /* The frame whose mini-buffer we're going to display the message
5700 on. It may be larger than the selected frame, so we need to
5701 use its buffer, not the selected frame's buffer. */
5702 Lisp_Object mini_window
;
5703 struct frame
*f
, *sf
= SELECTED_FRAME ();
5705 /* Get the frame containing the mini-buffer
5706 that the selected frame is using. */
5707 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
5708 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
5710 /* A null message buffer means that the frame hasn't really been
5711 initialized yet. Error messages get reported properly by
5712 cmd_error, so this must be just an informative message; toss
5714 if (FRAME_MESSAGE_BUF (f
))
5725 len
= doprnt (FRAME_MESSAGE_BUF (f
),
5726 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3, a
);
5728 len
= doprnt (FRAME_MESSAGE_BUF (f
),
5729 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, 3,
5731 #endif /* NO_ARG_ARRAY */
5733 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
5738 /* Print should start at the beginning of the message
5739 buffer next time. */
5740 message_buf_print
= 0;
5746 /* The non-logging version of message. */
5749 message_nolog (m
, a1
, a2
, a3
)
5751 EMACS_INT a1
, a2
, a3
;
5753 Lisp_Object old_log_max
;
5754 old_log_max
= Vmessage_log_max
;
5755 Vmessage_log_max
= Qnil
;
5756 message (m
, a1
, a2
, a3
);
5757 Vmessage_log_max
= old_log_max
;
5761 /* Display the current message in the current mini-buffer. This is
5762 only called from error handlers in process.c, and is not time
5768 if (!NILP (echo_area_buffer
[0]))
5771 string
= Fcurrent_message ();
5772 message3 (string
, XSTRING (string
)->size
,
5773 !NILP (current_buffer
->enable_multibyte_characters
));
5778 /* Make sure echo area buffers in echo_buffers[] are life. If they
5779 aren't, make new ones. */
5782 ensure_echo_area_buffers ()
5786 for (i
= 0; i
< 2; ++i
)
5787 if (!BUFFERP (echo_buffer
[i
])
5788 || NILP (XBUFFER (echo_buffer
[i
])->name
))
5791 Lisp_Object old_buffer
;
5794 old_buffer
= echo_buffer
[i
];
5795 sprintf (name
, " *Echo Area %d*", i
);
5796 echo_buffer
[i
] = Fget_buffer_create (build_string (name
));
5797 XBUFFER (echo_buffer
[i
])->truncate_lines
= Qnil
;
5799 for (j
= 0; j
< 2; ++j
)
5800 if (EQ (old_buffer
, echo_area_buffer
[j
]))
5801 echo_area_buffer
[j
] = echo_buffer
[i
];
5806 /* Call FN with args A1..A4 with either the current or last displayed
5807 echo_area_buffer as current buffer.
5809 WHICH zero means use the current message buffer
5810 echo_area_buffer[0]. If that is nil, choose a suitable buffer
5811 from echo_buffer[] and clear it.
5813 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
5814 suitable buffer from echo_buffer[] and clear it.
5816 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
5817 that the current message becomes the last displayed one, make
5818 choose a suitable buffer for echo_area_buffer[0], and clear it.
5820 Value is what FN returns. */
5823 with_echo_area_buffer (w
, which
, fn
, a1
, a2
, a3
, a4
)
5826 int (*fn
) P_ ((EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
));
5832 int this_one
, the_other
, clear_buffer_p
, rc
;
5833 int count
= BINDING_STACK_SIZE ();
5835 /* If buffers aren't life, make new ones. */
5836 ensure_echo_area_buffers ();
5841 this_one
= 0, the_other
= 1;
5843 this_one
= 1, the_other
= 0;
5846 this_one
= 0, the_other
= 1;
5849 /* We need a fresh one in case the current echo buffer equals
5850 the one containing the last displayed echo area message. */
5851 if (!NILP (echo_area_buffer
[this_one
])
5852 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
5853 echo_area_buffer
[this_one
] = Qnil
;
5856 /* Choose a suitable buffer from echo_buffer[] is we don't
5858 if (NILP (echo_area_buffer
[this_one
]))
5860 echo_area_buffer
[this_one
]
5861 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
5862 ? echo_buffer
[the_other
]
5863 : echo_buffer
[this_one
]);
5867 buffer
= echo_area_buffer
[this_one
];
5869 record_unwind_protect (unwind_with_echo_area_buffer
,
5870 with_echo_area_buffer_unwind_data (w
));
5872 /* Make the echo area buffer current. Note that for display
5873 purposes, it is not necessary that the displayed window's buffer
5874 == current_buffer, except for text property lookup. So, let's
5875 only set that buffer temporarily here without doing a full
5876 Fset_window_buffer. We must also change w->pointm, though,
5877 because otherwise an assertions in unshow_buffer fails, and Emacs
5879 set_buffer_internal_1 (XBUFFER (buffer
));
5883 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
5886 current_buffer
->undo_list
= Qt
;
5887 current_buffer
->read_only
= Qnil
;
5888 specbind (Qinhibit_read_only
, Qt
);
5890 if (clear_buffer_p
&& Z
> BEG
)
5893 xassert (BEGV
>= BEG
);
5894 xassert (ZV
<= Z
&& ZV
>= BEGV
);
5896 rc
= fn (a1
, a2
, a3
, a4
);
5898 xassert (BEGV
>= BEG
);
5899 xassert (ZV
<= Z
&& ZV
>= BEGV
);
5901 unbind_to (count
, Qnil
);
5906 /* Save state that should be preserved around the call to the function
5907 FN called in with_echo_area_buffer. */
5910 with_echo_area_buffer_unwind_data (w
)
5916 /* Reduce consing by keeping one vector in
5917 Vwith_echo_area_save_vector. */
5918 vector
= Vwith_echo_area_save_vector
;
5919 Vwith_echo_area_save_vector
= Qnil
;
5922 vector
= Fmake_vector (make_number (7), Qnil
);
5924 XSETBUFFER (XVECTOR (vector
)->contents
[i
], current_buffer
); ++i
;
5925 XVECTOR (vector
)->contents
[i
++] = Vdeactivate_mark
;
5926 XVECTOR (vector
)->contents
[i
++] = make_number (windows_or_buffers_changed
);
5930 XSETWINDOW (XVECTOR (vector
)->contents
[i
], w
); ++i
;
5931 XVECTOR (vector
)->contents
[i
++] = w
->buffer
;
5932 XVECTOR (vector
)->contents
[i
++]
5933 = make_number (XMARKER (w
->pointm
)->charpos
);
5934 XVECTOR (vector
)->contents
[i
++]
5935 = make_number (XMARKER (w
->pointm
)->bytepos
);
5941 XVECTOR (vector
)->contents
[i
++] = Qnil
;
5944 xassert (i
== XVECTOR (vector
)->size
);
5949 /* Restore global state from VECTOR which was created by
5950 with_echo_area_buffer_unwind_data. */
5953 unwind_with_echo_area_buffer (vector
)
5956 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
5957 Vdeactivate_mark
= AREF (vector
, 1);
5958 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
5960 if (WINDOWP (AREF (vector
, 3)))
5963 Lisp_Object buffer
, charpos
, bytepos
;
5965 w
= XWINDOW (AREF (vector
, 3));
5966 buffer
= AREF (vector
, 4);
5967 charpos
= AREF (vector
, 5);
5968 bytepos
= AREF (vector
, 6);
5971 set_marker_both (w
->pointm
, buffer
,
5972 XFASTINT (charpos
), XFASTINT (bytepos
));
5975 Vwith_echo_area_save_vector
= vector
;
5980 /* Set up the echo area for use by print functions. MULTIBYTE_P
5981 non-zero means we will print multibyte. */
5984 setup_echo_area_for_printing (multibyte_p
)
5987 ensure_echo_area_buffers ();
5989 if (!message_buf_print
)
5991 /* A message has been output since the last time we printed.
5992 Choose a fresh echo area buffer. */
5993 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
5994 echo_area_buffer
[0] = echo_buffer
[1];
5996 echo_area_buffer
[0] = echo_buffer
[0];
5998 /* Switch to that buffer and clear it. */
5999 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
6003 int count
= BINDING_STACK_SIZE ();
6004 specbind (Qinhibit_read_only
, Qt
);
6006 unbind_to (count
, Qnil
);
6008 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
6010 /* Set up the buffer for the multibyteness we need. */
6012 != !NILP (current_buffer
->enable_multibyte_characters
))
6013 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
6015 /* Raise the frame containing the echo area. */
6016 if (minibuffer_auto_raise
)
6018 struct frame
*sf
= SELECTED_FRAME ();
6019 Lisp_Object mini_window
;
6020 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6021 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
6024 message_log_maybe_newline ();
6025 message_buf_print
= 1;
6029 if (NILP (echo_area_buffer
[0]))
6031 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
6032 echo_area_buffer
[0] = echo_buffer
[1];
6034 echo_area_buffer
[0] = echo_buffer
[0];
6037 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
6038 /* Someone switched buffers between print requests. */
6039 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
6044 /* Display an echo area message in window W. Value is non-zero if W's
6045 height is changed. If display_last_displayed_message_p is
6046 non-zero, display the message that was last displayed, otherwise
6047 display the current message. */
6050 display_echo_area (w
)
6053 int i
, no_message_p
, window_height_changed_p
, count
;
6055 /* Temporarily disable garbage collections while displaying the echo
6056 area. This is done because a GC can print a message itself.
6057 That message would modify the echo area buffer's contents while a
6058 redisplay of the buffer is going on, and seriously confuse
6060 count
= inhibit_garbage_collection ();
6062 /* If there is no message, we must call display_echo_area_1
6063 nevertheless because it resizes the window. But we will have to
6064 reset the echo_area_buffer in question to nil at the end because
6065 with_echo_area_buffer will sets it to an empty buffer. */
6066 i
= display_last_displayed_message_p
? 1 : 0;
6067 no_message_p
= NILP (echo_area_buffer
[i
]);
6069 window_height_changed_p
6070 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
6071 display_echo_area_1
,
6072 (EMACS_INT
) w
, Qnil
, 0, 0);
6075 echo_area_buffer
[i
] = Qnil
;
6077 unbind_to (count
, Qnil
);
6078 return window_height_changed_p
;
6082 /* Helper for display_echo_area. Display the current buffer which
6083 contains the current echo area message in window W, a mini-window,
6084 a pointer to which is passed in A1. A2..A4 are currently not used.
6085 Change the height of W so that all of the message is displayed.
6086 Value is non-zero if height of W was changed. */
6089 display_echo_area_1 (a1
, a2
, a3
, a4
)
6094 struct window
*w
= (struct window
*) a1
;
6096 struct text_pos start
;
6097 int window_height_changed_p
= 0;
6099 /* Do this before displaying, so that we have a large enough glyph
6100 matrix for the display. */
6101 window_height_changed_p
= resize_mini_window (w
, 0);
6104 clear_glyph_matrix (w
->desired_matrix
);
6105 XSETWINDOW (window
, w
);
6106 SET_TEXT_POS (start
, BEG
, BEG_BYTE
);
6107 try_window (window
, start
);
6109 return window_height_changed_p
;
6113 /* Resize the echo area window to exactly the size needed for the
6114 currently displayed message, if there is one. */
6117 resize_echo_area_axactly ()
6119 if (BUFFERP (echo_area_buffer
[0])
6120 && WINDOWP (echo_area_window
))
6122 struct window
*w
= XWINDOW (echo_area_window
);
6125 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
6126 (EMACS_INT
) w
, Qnil
, 0, 0);
6129 ++windows_or_buffers_changed
;
6130 ++update_mode_lines
;
6131 redisplay_internal (0);
6137 /* Callback function for with_echo_area_buffer, when used from
6138 resize_echo_area_axactly. A1 contains a pointer to the window to
6139 resize, A2 to A4 are not used. Value is what resize_mini_window
6143 resize_mini_window_1 (a1
, a2
, a3
, a4
)
6148 return resize_mini_window ((struct window
*) a1
, 1);
6152 /* Resize mini-window W to fit the size of its contents. EXACT:P
6153 means size the window exactly to the size needed. Otherwise, it's
6154 only enlarged until W's buffer is empty. Value is non-zero if
6155 the window height has been changed. */
6158 resize_mini_window (w
, exact_p
)
6162 struct frame
*f
= XFRAME (w
->frame
);
6163 int window_height_changed_p
= 0;
6165 xassert (MINI_WINDOW_P (w
));
6167 /* Nil means don't try to resize. */
6168 if (NILP (Vresize_mini_windows
)
6169 || (FRAME_X_P (f
) && f
->output_data
.x
== NULL
))
6172 if (!FRAME_MINIBUF_ONLY_P (f
))
6175 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
6176 int total_height
= XFASTINT (root
->height
) + XFASTINT (w
->height
);
6177 int height
, max_height
;
6178 int unit
= CANON_Y_UNIT (f
);
6179 struct text_pos start
;
6180 struct buffer
*old_current_buffer
= NULL
;
6182 if (current_buffer
!= XBUFFER (w
->buffer
))
6184 old_current_buffer
= current_buffer
;
6185 set_buffer_internal (XBUFFER (w
->buffer
));
6188 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
6190 /* Compute the max. number of lines specified by the user. */
6191 if (FLOATP (Vmax_mini_window_height
))
6192 max_height
= XFLOATINT (Vmax_mini_window_height
) * total_height
;
6193 else if (INTEGERP (Vmax_mini_window_height
))
6194 max_height
= XINT (Vmax_mini_window_height
);
6196 max_height
= total_height
/ 4;
6198 /* Correct that max. height if it's bogus. */
6199 max_height
= max (1, max_height
);
6200 max_height
= min (total_height
, max_height
);
6202 /* Find out the height of the text in the window. */
6203 if (it
.truncate_lines_p
)
6208 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
6209 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
6210 height
= it
.current_y
+ last_height
;
6212 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
6213 height
-= it
.extra_line_spacing
;
6214 height
= (height
+ unit
- 1) / unit
;
6217 /* Compute a suitable window start. */
6218 if (height
> max_height
)
6220 height
= max_height
;
6221 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
6222 move_it_vertically_backward (&it
, (height
- 1) * unit
);
6223 start
= it
.current
.pos
;
6226 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
6227 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
6229 if (EQ (Vresize_mini_windows
, Qgrow_only
))
6231 /* Let it grow only, until we display an empty message, in which
6232 case the window shrinks again. */
6233 if (height
> XFASTINT (w
->height
))
6235 int old_height
= XFASTINT (w
->height
);
6236 freeze_window_starts (f
, 1);
6237 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6238 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6240 else if (height
< XFASTINT (w
->height
)
6241 && (exact_p
|| BEGV
== ZV
))
6243 int old_height
= XFASTINT (w
->height
);
6244 freeze_window_starts (f
, 0);
6245 shrink_mini_window (w
);
6246 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6251 /* Always resize to exact size needed. */
6252 if (height
> XFASTINT (w
->height
))
6254 int old_height
= XFASTINT (w
->height
);
6255 freeze_window_starts (f
, 1);
6256 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6257 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6259 else if (height
< XFASTINT (w
->height
))
6261 int old_height
= XFASTINT (w
->height
);
6262 freeze_window_starts (f
, 0);
6263 shrink_mini_window (w
);
6267 freeze_window_starts (f
, 1);
6268 grow_mini_window (w
, height
- XFASTINT (w
->height
));
6271 window_height_changed_p
= XFASTINT (w
->height
) != old_height
;
6275 if (old_current_buffer
)
6276 set_buffer_internal (old_current_buffer
);
6279 return window_height_changed_p
;
6283 /* Value is the current message, a string, or nil if there is no
6291 if (NILP (echo_area_buffer
[0]))
6295 with_echo_area_buffer (0, 0, current_message_1
,
6296 (EMACS_INT
) &msg
, Qnil
, 0, 0);
6298 echo_area_buffer
[0] = Qnil
;
6306 current_message_1 (a1
, a2
, a3
, a4
)
6311 Lisp_Object
*msg
= (Lisp_Object
*) a1
;
6314 *msg
= make_buffer_string (BEG
, Z
, 1);
6321 /* Push the current message on Vmessage_stack for later restauration
6322 by restore_message. Value is non-zero if the current message isn't
6323 empty. This is a relatively infrequent operation, so it's not
6324 worth optimizing. */
6330 msg
= current_message ();
6331 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
6332 return STRINGP (msg
);
6336 /* Restore message display from the top of Vmessage_stack. */
6343 xassert (CONSP (Vmessage_stack
));
6344 msg
= XCAR (Vmessage_stack
);
6346 message3_nolog (msg
, STRING_BYTES (XSTRING (msg
)), STRING_MULTIBYTE (msg
));
6348 message3_nolog (msg
, 0, 0);
6352 /* Pop the top-most entry off Vmessage_stack. */
6357 xassert (CONSP (Vmessage_stack
));
6358 Vmessage_stack
= XCDR (Vmessage_stack
);
6362 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
6363 exits. If the stack is not empty, we have a missing pop_message
6367 check_message_stack ()
6369 if (!NILP (Vmessage_stack
))
6374 /* Truncate to NCHARS what will be displayed in the echo area the next
6375 time we display it---but don't redisplay it now. */
6378 truncate_echo_area (nchars
)
6382 echo_area_buffer
[0] = Qnil
;
6383 /* A null message buffer means that the frame hasn't really been
6384 initialized yet. Error messages get reported properly by
6385 cmd_error, so this must be just an informative message; toss it. */
6386 else if (!noninteractive
6388 && !NILP (echo_area_buffer
[0]))
6390 struct frame
*sf
= SELECTED_FRAME ();
6391 if (FRAME_MESSAGE_BUF (sf
))
6392 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
6397 /* Helper function for truncate_echo_area. Truncate the current
6398 message to at most NCHARS characters. */
6401 truncate_message_1 (nchars
, a2
, a3
, a4
)
6406 if (BEG
+ nchars
< Z
)
6407 del_range (BEG
+ nchars
, Z
);
6409 echo_area_buffer
[0] = Qnil
;
6414 /* Set the current message to a substring of S or STRING.
6416 If STRING is a Lisp string, set the message to the first NBYTES
6417 bytes from STRING. NBYTES zero means use the whole string. If
6418 STRING is multibyte, the message will be displayed multibyte.
6420 If S is not null, set the message to the first LEN bytes of S. LEN
6421 zero means use the whole string. MULTIBYTE_P non-zero means S is
6422 multibyte. Display the message multibyte in that case. */
6425 set_message (s
, string
, nbytes
, multibyte_p
)
6430 message_enable_multibyte
6431 = ((s
&& multibyte_p
)
6432 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
6434 with_echo_area_buffer (0, -1, set_message_1
,
6435 (EMACS_INT
) s
, string
, nbytes
, multibyte_p
);
6436 message_buf_print
= 0;
6437 help_echo_showing_p
= 0;
6441 /* Helper function for set_message. Arguments have the same meaning
6442 as there, with A1 corresponding to S and A2 corresponding to STRING
6443 This function is called with the echo area buffer being
6447 set_message_1 (a1
, a2
, nbytes
, multibyte_p
)
6450 EMACS_INT nbytes
, multibyte_p
;
6452 char *s
= (char *) a1
;
6453 Lisp_Object string
= a2
;
6457 /* Change multibyteness of the echo buffer appropriately. */
6458 if (message_enable_multibyte
6459 != !NILP (current_buffer
->enable_multibyte_characters
))
6460 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
6462 current_buffer
->truncate_lines
= message_truncate_lines
? Qt
: Qnil
;
6464 /* Insert new message at BEG. */
6465 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
6467 if (STRINGP (string
))
6472 nbytes
= XSTRING (string
)->size_byte
;
6473 nchars
= string_byte_to_char (string
, nbytes
);
6475 /* This function takes care of single/multibyte conversion. We
6476 just have to ensure that the echo area buffer has the right
6477 setting of enable_multibyte_characters. */
6478 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
6483 nbytes
= strlen (s
);
6485 if (multibyte_p
&& NILP (current_buffer
->enable_multibyte_characters
))
6487 /* Convert from multi-byte to single-byte. */
6489 unsigned char work
[1];
6491 /* Convert a multibyte string to single-byte. */
6492 for (i
= 0; i
< nbytes
; i
+= n
)
6494 c
= string_char_and_length (s
+ i
, nbytes
- i
, &n
);
6495 work
[0] = (SINGLE_BYTE_CHAR_P (c
)
6497 : multibyte_char_to_unibyte (c
, Qnil
));
6498 insert_1_both (work
, 1, 1, 1, 0, 0);
6501 else if (!multibyte_p
6502 && !NILP (current_buffer
->enable_multibyte_characters
))
6504 /* Convert from single-byte to multi-byte. */
6506 unsigned char *msg
= (unsigned char *) s
;
6507 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
6509 /* Convert a single-byte string to multibyte. */
6510 for (i
= 0; i
< nbytes
; i
++)
6512 c
= unibyte_char_to_multibyte (msg
[i
]);
6513 n
= CHAR_STRING (c
, str
);
6514 insert_1_both (str
, 1, n
, 1, 0, 0);
6518 insert_1 (s
, nbytes
, 1, 0, 0);
6525 /* Clear messages. CURRENT_P non-zero means clear the current
6526 message. LAST_DISPLAYED_P non-zero means clear the message
6530 clear_message (current_p
, last_displayed_p
)
6531 int current_p
, last_displayed_p
;
6534 echo_area_buffer
[0] = Qnil
;
6536 if (last_displayed_p
)
6537 echo_area_buffer
[1] = Qnil
;
6539 message_buf_print
= 0;
6542 /* Clear garbaged frames.
6544 This function is used where the old redisplay called
6545 redraw_garbaged_frames which in turn called redraw_frame which in
6546 turn called clear_frame. The call to clear_frame was a source of
6547 flickering. I believe a clear_frame is not necessary. It should
6548 suffice in the new redisplay to invalidate all current matrices,
6549 and ensure a complete redisplay of all windows. */
6552 clear_garbaged_frames ()
6556 Lisp_Object tail
, frame
;
6558 FOR_EACH_FRAME (tail
, frame
)
6560 struct frame
*f
= XFRAME (frame
);
6562 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
6564 clear_current_matrices (f
);
6570 ++windows_or_buffers_changed
;
6575 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
6576 is non-zero update selected_frame. Value is non-zero if the
6577 mini-windows height has been changed. */
6580 echo_area_display (update_frame_p
)
6583 Lisp_Object mini_window
;
6586 int window_height_changed_p
= 0;
6587 struct frame
*sf
= SELECTED_FRAME ();
6589 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
6590 w
= XWINDOW (mini_window
);
6591 f
= XFRAME (WINDOW_FRAME (w
));
6593 /* Don't display if frame is invisible or not yet initialized. */
6594 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
6597 /* The terminal frame is used as the first Emacs frame on the Mac OS. */
6599 #ifdef HAVE_WINDOW_SYSTEM
6600 /* When Emacs starts, selected_frame may be a visible terminal
6601 frame, even if we run under a window system. If we let this
6602 through, a message would be displayed on the terminal. */
6603 if (EQ (selected_frame
, Vterminal_frame
)
6604 && !NILP (Vwindow_system
))
6606 #endif /* HAVE_WINDOW_SYSTEM */
6609 /* Redraw garbaged frames. */
6611 clear_garbaged_frames ();
6613 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
6615 echo_area_window
= mini_window
;
6616 window_height_changed_p
= display_echo_area (w
);
6617 w
->must_be_updated_p
= 1;
6619 /* Update the display, unless called from redisplay_internal.
6620 Also don't update the screen during redisplay itself. The
6621 update will happen at the end of redisplay, and an update
6622 here could cause confusion. */
6623 if (update_frame_p
&& !redisplaying_p
)
6627 /* If the display update has been interrupted by pending
6628 input, update mode lines in the frame. Due to the
6629 pending input, it might have been that redisplay hasn't
6630 been called, so that mode lines above the echo area are
6631 garbaged. This looks odd, so we prevent it here. */
6632 if (!display_completed
)
6633 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
6635 if (window_height_changed_p
)
6637 /* Must update other windows. Likewise as in other
6638 cases, don't let this update be interrupted by
6640 int count
= BINDING_STACK_SIZE ();
6641 specbind (Qredisplay_dont_pause
, Qt
);
6642 windows_or_buffers_changed
= 1;
6643 redisplay_internal (0);
6644 unbind_to (count
, Qnil
);
6646 else if (FRAME_WINDOW_P (f
) && n
== 0)
6648 /* Window configuration is the same as before.
6649 Can do with a display update of the echo area,
6650 unless we displayed some mode lines. */
6651 update_single_window (w
, 1);
6652 rif
->flush_display (f
);
6655 update_frame (f
, 1, 1);
6657 /* If cursor is in the echo area, make sure that the next
6658 redisplay displays the minibuffer, so that the cursor will
6659 be replaced with what the minibuffer wants. */
6660 if (cursor_in_echo_area
)
6661 ++windows_or_buffers_changed
;
6664 else if (!EQ (mini_window
, selected_window
))
6665 windows_or_buffers_changed
++;
6667 /* Last displayed message is now the current message. */
6668 echo_area_buffer
[1] = echo_area_buffer
[0];
6670 /* Prevent redisplay optimization in redisplay_internal by resetting
6671 this_line_start_pos. This is done because the mini-buffer now
6672 displays the message instead of its buffer text. */
6673 if (EQ (mini_window
, selected_window
))
6674 CHARPOS (this_line_start_pos
) = 0;
6676 return window_height_changed_p
;
6681 /***********************************************************************
6683 ***********************************************************************/
6686 #ifdef HAVE_WINDOW_SYSTEM
6688 /* A buffer for constructing frame titles in it; allocated from the
6689 heap in init_xdisp and resized as needed in store_frame_title_char. */
6691 static char *frame_title_buf
;
6693 /* The buffer's end, and a current output position in it. */
6695 static char *frame_title_buf_end
;
6696 static char *frame_title_ptr
;
6699 /* Store a single character C for the frame title in frame_title_buf.
6700 Re-allocate frame_title_buf if necessary. */
6703 store_frame_title_char (c
)
6706 /* If output position has reached the end of the allocated buffer,
6707 double the buffer's size. */
6708 if (frame_title_ptr
== frame_title_buf_end
)
6710 int len
= frame_title_ptr
- frame_title_buf
;
6711 int new_size
= 2 * len
* sizeof *frame_title_buf
;
6712 frame_title_buf
= (char *) xrealloc (frame_title_buf
, new_size
);
6713 frame_title_buf_end
= frame_title_buf
+ new_size
;
6714 frame_title_ptr
= frame_title_buf
+ len
;
6717 *frame_title_ptr
++ = c
;
6721 /* Store part of a frame title in frame_title_buf, beginning at
6722 frame_title_ptr. STR is the string to store. Do not copy more
6723 than PRECISION number of bytes from STR; PRECISION <= 0 means copy
6724 the whole string. Pad with spaces until FIELD_WIDTH number of
6725 characters have been copied; FIELD_WIDTH <= 0 means don't pad.
6726 Called from display_mode_element when it is used to build a frame
6730 store_frame_title (str
, field_width
, precision
)
6732 int field_width
, precision
;
6736 /* Copy at most PRECISION chars from STR. */
6737 while ((precision
<= 0 || n
< precision
)
6740 store_frame_title_char (*str
++);
6744 /* Fill up with spaces until FIELD_WIDTH reached. */
6745 while (field_width
> 0
6748 store_frame_title_char (' ');
6756 /* Set the title of FRAME, if it has changed. The title format is
6757 Vicon_title_format if FRAME is iconified, otherwise it is
6758 frame_title_format. */
6761 x_consider_frame_title (frame
)
6764 struct frame
*f
= XFRAME (frame
);
6766 if (FRAME_WINDOW_P (f
)
6767 || FRAME_MINIBUF_ONLY_P (f
)
6768 || f
->explicit_name
)
6770 /* Do we have more than one visible frame on this X display? */
6773 struct buffer
*obuf
;
6777 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
6779 struct frame
*tf
= XFRAME (XCAR (tail
));
6782 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
6783 && !FRAME_MINIBUF_ONLY_P (tf
)
6784 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
6788 /* Set global variable indicating that multiple frames exist. */
6789 multiple_frames
= CONSP (tail
);
6791 /* Switch to the buffer of selected window of the frame. Set up
6792 frame_title_ptr so that display_mode_element will output into it;
6793 then display the title. */
6794 obuf
= current_buffer
;
6795 Fset_buffer (XWINDOW (f
->selected_window
)->buffer
);
6796 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
6797 frame_title_ptr
= frame_title_buf
;
6798 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
6799 NULL
, DEFAULT_FACE_ID
);
6800 len
= display_mode_element (&it
, 0, -1, -1, fmt
);
6801 frame_title_ptr
= NULL
;
6802 set_buffer_internal (obuf
);
6804 /* Set the title only if it's changed. This avoids consing in
6805 the common case where it hasn't. (If it turns out that we've
6806 already wasted too much time by walking through the list with
6807 display_mode_element, then we might need to optimize at a
6808 higher level than this.) */
6809 if (! STRINGP (f
->name
)
6810 || STRING_BYTES (XSTRING (f
->name
)) != len
6811 || bcmp (frame_title_buf
, XSTRING (f
->name
)->data
, len
) != 0)
6812 x_implicitly_set_name (f
, make_string (frame_title_buf
, len
), Qnil
);
6816 #else /* not HAVE_WINDOW_SYSTEM */
6818 #define frame_title_ptr ((char *)0)
6819 #define store_frame_title(str, mincol, maxcol) 0
6821 #endif /* not HAVE_WINDOW_SYSTEM */
6826 /***********************************************************************
6828 ***********************************************************************/
6831 /* Prepare for redisplay by updating menu-bar item lists when
6832 appropriate. This can call eval. */
6835 prepare_menu_bars ()
6838 struct gcpro gcpro1
, gcpro2
;
6840 Lisp_Object tooltip_frame
;
6842 #ifdef HAVE_X_WINDOWS
6843 tooltip_frame
= tip_frame
;
6845 tooltip_frame
= Qnil
;
6848 /* Update all frame titles based on their buffer names, etc. We do
6849 this before the menu bars so that the buffer-menu will show the
6850 up-to-date frame titles. */
6851 #ifdef HAVE_WINDOW_SYSTEM
6852 if (windows_or_buffers_changed
|| update_mode_lines
)
6854 Lisp_Object tail
, frame
;
6856 FOR_EACH_FRAME (tail
, frame
)
6859 if (!EQ (frame
, tooltip_frame
)
6860 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
6861 x_consider_frame_title (frame
);
6864 #endif /* HAVE_WINDOW_SYSTEM */
6866 /* Update the menu bar item lists, if appropriate. This has to be
6867 done before any actual redisplay or generation of display lines. */
6868 all_windows
= (update_mode_lines
6869 || buffer_shared
> 1
6870 || windows_or_buffers_changed
);
6873 Lisp_Object tail
, frame
;
6874 int count
= BINDING_STACK_SIZE ();
6876 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
6878 FOR_EACH_FRAME (tail
, frame
)
6882 /* Ignore tooltip frame. */
6883 if (EQ (frame
, tooltip_frame
))
6886 /* If a window on this frame changed size, report that to
6887 the user and clear the size-change flag. */
6888 if (FRAME_WINDOW_SIZES_CHANGED (f
))
6890 Lisp_Object functions
;
6892 /* Clear flag first in case we get an error below. */
6893 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
6894 functions
= Vwindow_size_change_functions
;
6895 GCPRO2 (tail
, functions
);
6897 while (CONSP (functions
))
6899 call1 (XCAR (functions
), frame
);
6900 functions
= XCDR (functions
);
6906 update_menu_bar (f
, 0);
6907 #ifdef HAVE_WINDOW_SYSTEM
6908 update_tool_bar (f
, 0);
6913 unbind_to (count
, Qnil
);
6917 struct frame
*sf
= SELECTED_FRAME ();
6918 update_menu_bar (sf
, 1);
6919 #ifdef HAVE_WINDOW_SYSTEM
6920 update_tool_bar (sf
, 1);
6924 /* Motif needs this. See comment in xmenu.c. Turn it off when
6925 pending_menu_activation is not defined. */
6926 #ifdef USE_X_TOOLKIT
6927 pending_menu_activation
= 0;
6932 /* Update the menu bar item list for frame F. This has to be done
6933 before we start to fill in any display lines, because it can call
6936 If SAVE_MATCH_DATA is non-zero, we must save and restore it here. */
6939 update_menu_bar (f
, save_match_data
)
6941 int save_match_data
;
6944 register struct window
*w
;
6946 window
= FRAME_SELECTED_WINDOW (f
);
6947 w
= XWINDOW (window
);
6949 if (update_mode_lines
)
6950 w
->update_mode_line
= Qt
;
6952 if (FRAME_WINDOW_P (f
)
6954 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
6955 FRAME_EXTERNAL_MENU_BAR (f
)
6957 FRAME_MENU_BAR_LINES (f
) > 0
6959 : FRAME_MENU_BAR_LINES (f
) > 0)
6961 /* If the user has switched buffers or windows, we need to
6962 recompute to reflect the new bindings. But we'll
6963 recompute when update_mode_lines is set too; that means
6964 that people can use force-mode-line-update to request
6965 that the menu bar be recomputed. The adverse effect on
6966 the rest of the redisplay algorithm is about the same as
6967 windows_or_buffers_changed anyway. */
6968 if (windows_or_buffers_changed
6969 || !NILP (w
->update_mode_line
)
6970 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
6971 < BUF_MODIFF (XBUFFER (w
->buffer
)))
6972 != !NILP (w
->last_had_star
))
6973 || ((!NILP (Vtransient_mark_mode
)
6974 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
6975 != !NILP (w
->region_showing
)))
6977 struct buffer
*prev
= current_buffer
;
6978 int count
= BINDING_STACK_SIZE ();
6980 set_buffer_internal_1 (XBUFFER (w
->buffer
));
6981 if (save_match_data
)
6982 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
6983 if (NILP (Voverriding_local_map_menu_flag
))
6985 specbind (Qoverriding_terminal_local_map
, Qnil
);
6986 specbind (Qoverriding_local_map
, Qnil
);
6989 /* Run the Lucid hook. */
6990 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
6992 /* If it has changed current-menubar from previous value,
6993 really recompute the menu-bar from the value. */
6994 if (! NILP (Vlucid_menu_bar_dirty_flag
))
6995 call0 (Qrecompute_lucid_menubar
);
6997 safe_run_hooks (Qmenu_bar_update_hook
);
6998 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
7000 /* Redisplay the menu bar in case we changed it. */
7001 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
7002 if (FRAME_WINDOW_P (f
)
7003 #if defined (macintosh)
7004 /* All frames on Mac OS share the same menubar. So only the
7005 selected frame should be allowed to set it. */
7006 && f
== SELECTED_FRAME ()
7009 set_frame_menubar (f
, 0, 0);
7011 /* On a terminal screen, the menu bar is an ordinary screen
7012 line, and this makes it get updated. */
7013 w
->update_mode_line
= Qt
;
7014 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
7015 /* In the non-toolkit version, the menu bar is an ordinary screen
7016 line, and this makes it get updated. */
7017 w
->update_mode_line
= Qt
;
7018 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI) */
7020 unbind_to (count
, Qnil
);
7021 set_buffer_internal_1 (prev
);
7028 /***********************************************************************
7030 ***********************************************************************/
7032 #ifdef HAVE_WINDOW_SYSTEM
7034 /* Update the tool-bar item list for frame F. This has to be done
7035 before we start to fill in any display lines. Called from
7036 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
7037 and restore it here. */
7040 update_tool_bar (f
, save_match_data
)
7042 int save_match_data
;
7044 if (WINDOWP (f
->tool_bar_window
)
7045 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
) > 0)
7050 window
= FRAME_SELECTED_WINDOW (f
);
7051 w
= XWINDOW (window
);
7053 /* If the user has switched buffers or windows, we need to
7054 recompute to reflect the new bindings. But we'll
7055 recompute when update_mode_lines is set too; that means
7056 that people can use force-mode-line-update to request
7057 that the menu bar be recomputed. The adverse effect on
7058 the rest of the redisplay algorithm is about the same as
7059 windows_or_buffers_changed anyway. */
7060 if (windows_or_buffers_changed
7061 || !NILP (w
->update_mode_line
)
7062 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
7063 < BUF_MODIFF (XBUFFER (w
->buffer
)))
7064 != !NILP (w
->last_had_star
))
7065 || ((!NILP (Vtransient_mark_mode
)
7066 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
7067 != !NILP (w
->region_showing
)))
7069 struct buffer
*prev
= current_buffer
;
7070 int count
= BINDING_STACK_SIZE ();
7072 /* Set current_buffer to the buffer of the selected
7073 window of the frame, so that we get the right local
7075 set_buffer_internal_1 (XBUFFER (w
->buffer
));
7077 /* Save match data, if we must. */
7078 if (save_match_data
)
7079 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
7081 /* Make sure that we don't accidentally use bogus keymaps. */
7082 if (NILP (Voverriding_local_map_menu_flag
))
7084 specbind (Qoverriding_terminal_local_map
, Qnil
);
7085 specbind (Qoverriding_local_map
, Qnil
);
7088 /* Build desired tool-bar items from keymaps. */
7090 = tool_bar_items (f
->tool_bar_items
, &f
->n_tool_bar_items
);
7092 /* Redisplay the tool-bar in case we changed it. */
7093 w
->update_mode_line
= Qt
;
7095 unbind_to (count
, Qnil
);
7096 set_buffer_internal_1 (prev
);
7102 /* Set F->desired_tool_bar_string to a Lisp string representing frame
7103 F's desired tool-bar contents. F->tool_bar_items must have
7104 been set up previously by calling prepare_menu_bars. */
7107 build_desired_tool_bar_string (f
)
7110 int i
, size
, size_needed
, string_idx
;
7111 struct gcpro gcpro1
, gcpro2
, gcpro3
;
7112 Lisp_Object image
, plist
, props
;
7114 image
= plist
= props
= Qnil
;
7115 GCPRO3 (image
, plist
, props
);
7117 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
7118 Otherwise, make a new string. */
7120 /* The size of the string we might be able to reuse. */
7121 size
= (STRINGP (f
->desired_tool_bar_string
)
7122 ? XSTRING (f
->desired_tool_bar_string
)->size
7125 /* Each image in the string we build is preceded by a space,
7126 and there is a space at the end. */
7127 size_needed
= f
->n_tool_bar_items
+ 1;
7129 /* Reuse f->desired_tool_bar_string, if possible. */
7130 if (size
< size_needed
)
7131 f
->desired_tool_bar_string
= Fmake_string (make_number (size_needed
),
7135 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
7136 Fremove_text_properties (make_number (0), make_number (size
),
7137 props
, f
->desired_tool_bar_string
);
7140 /* Put a `display' property on the string for the images to display,
7141 put a `menu_item' property on tool-bar items with a value that
7142 is the index of the item in F's tool-bar item vector. */
7143 for (i
= 0, string_idx
= 0;
7144 i
< f
->n_tool_bar_items
;
7145 ++i
, string_idx
+= 1)
7147 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
7149 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7150 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7151 int margin
, relief
, idx
;
7152 extern Lisp_Object QCrelief
, QCmargin
, QCalgorithm
, Qimage
;
7153 extern Lisp_Object Qlaplace
;
7155 /* If image is a vector, choose the image according to the
7157 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
7158 if (VECTORP (image
))
7162 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
7163 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
7166 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
7167 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
7169 xassert (ASIZE (image
) >= idx
);
7170 image
= AREF (image
, idx
);
7175 /* Ignore invalid image specifications. */
7176 if (!valid_image_p (image
))
7179 /* Display the tool-bar button pressed, or depressed. */
7180 plist
= Fcopy_sequence (XCDR (image
));
7182 /* Compute margin and relief to draw. */
7183 relief
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
7184 margin
= relief
+ max (0, tool_bar_button_margin
);
7186 if (auto_raise_tool_bar_buttons_p
)
7188 /* Add a `:relief' property to the image spec if the item is
7192 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
7198 /* If image is selected, display it pressed, i.e. with a
7199 negative relief. If it's not selected, display it with a
7201 plist
= Fplist_put (plist
, QCrelief
,
7203 ? make_number (-relief
)
7204 : make_number (relief
)));
7208 /* Put a margin around the image. */
7210 plist
= Fplist_put (plist
, QCmargin
, make_number (margin
));
7212 /* If button is not enabled, and we don't have special images
7213 for the disabled state, make the image appear disabled by
7214 applying an appropriate algorithm to it. */
7215 if (!enabled_p
&& idx
< 0)
7216 plist
= Fplist_put (plist
, QCalgorithm
, Qdisabled
);
7218 /* Put a `display' text property on the string for the image to
7219 display. Put a `menu-item' property on the string that gives
7220 the start of this item's properties in the tool-bar items
7222 image
= Fcons (Qimage
, plist
);
7223 props
= list4 (Qdisplay
, image
,
7224 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
)),
7225 Fadd_text_properties (make_number (string_idx
),
7226 make_number (string_idx
+ 1),
7227 props
, f
->desired_tool_bar_string
);
7235 /* Display one line of the tool-bar of frame IT->f. */
7238 display_tool_bar_line (it
)
7241 struct glyph_row
*row
= it
->glyph_row
;
7242 int max_x
= it
->last_visible_x
;
7245 prepare_desired_row (row
);
7246 row
->y
= it
->current_y
;
7248 /* Note that this isn't made use of if the face hasn't a box,
7249 so there's no need to check the face here. */
7250 it
->start_of_box_run_p
= 1;
7252 while (it
->current_x
< max_x
)
7254 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
7256 /* Get the next display element. */
7257 if (!get_next_display_element (it
))
7260 /* Produce glyphs. */
7261 x_before
= it
->current_x
;
7262 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
7263 PRODUCE_GLYPHS (it
);
7265 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
7270 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
7272 if (x
+ glyph
->pixel_width
> max_x
)
7274 /* Glyph doesn't fit on line. */
7275 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
7281 x
+= glyph
->pixel_width
;
7285 /* Stop at line ends. */
7286 if (ITERATOR_AT_END_OF_LINE_P (it
))
7289 set_iterator_to_next (it
, 1);
7294 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
7295 extend_face_to_end_of_line (it
);
7296 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
7297 last
->right_box_line_p
= 1;
7298 if (last
== row
->glyphs
[TEXT_AREA
])
7299 last
->left_box_line_p
= 1;
7300 compute_line_metrics (it
);
7302 /* If line is empty, make it occupy the rest of the tool-bar. */
7303 if (!row
->displays_text_p
)
7305 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
7306 row
->ascent
= row
->phys_ascent
= 0;
7309 row
->full_width_p
= 1;
7310 row
->continued_p
= 0;
7311 row
->truncated_on_left_p
= 0;
7312 row
->truncated_on_right_p
= 0;
7314 it
->current_x
= it
->hpos
= 0;
7315 it
->current_y
+= row
->height
;
7321 /* Value is the number of screen lines needed to make all tool-bar
7322 items of frame F visible. */
7325 tool_bar_lines_needed (f
)
7328 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7331 /* Initialize an iterator for iteration over
7332 F->desired_tool_bar_string in the tool-bar window of frame F. */
7333 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
7334 it
.first_visible_x
= 0;
7335 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
7336 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
7338 while (!ITERATOR_AT_END_P (&it
))
7340 it
.glyph_row
= w
->desired_matrix
->rows
;
7341 clear_glyph_row (it
.glyph_row
);
7342 display_tool_bar_line (&it
);
7345 return (it
.current_y
+ CANON_Y_UNIT (f
) - 1) / CANON_Y_UNIT (f
);
7349 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
7350 height should be changed. */
7353 redisplay_tool_bar (f
)
7358 struct glyph_row
*row
;
7359 int change_height_p
= 0;
7361 /* If frame hasn't a tool-bar window or if it is zero-height, don't
7362 do anything. This means you must start with tool-bar-lines
7363 non-zero to get the auto-sizing effect. Or in other words, you
7364 can turn off tool-bars by specifying tool-bar-lines zero. */
7365 if (!WINDOWP (f
->tool_bar_window
)
7366 || (w
= XWINDOW (f
->tool_bar_window
),
7367 XFASTINT (w
->height
) == 0))
7370 /* Set up an iterator for the tool-bar window. */
7371 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
7372 it
.first_visible_x
= 0;
7373 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
7376 /* Build a string that represents the contents of the tool-bar. */
7377 build_desired_tool_bar_string (f
);
7378 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
7380 /* Display as many lines as needed to display all tool-bar items. */
7381 while (it
.current_y
< it
.last_visible_y
)
7382 display_tool_bar_line (&it
);
7384 /* It doesn't make much sense to try scrolling in the tool-bar
7385 window, so don't do it. */
7386 w
->desired_matrix
->no_scrolling_p
= 1;
7387 w
->must_be_updated_p
= 1;
7389 if (auto_resize_tool_bars_p
)
7393 /* If there are blank lines at the end, except for a partially
7394 visible blank line at the end that is smaller than
7395 CANON_Y_UNIT, change the tool-bar's height. */
7396 row
= it
.glyph_row
- 1;
7397 if (!row
->displays_text_p
7398 && row
->height
>= CANON_Y_UNIT (f
))
7399 change_height_p
= 1;
7401 /* If row displays tool-bar items, but is partially visible,
7402 change the tool-bar's height. */
7403 if (row
->displays_text_p
7404 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
)
7405 change_height_p
= 1;
7407 /* Resize windows as needed by changing the `tool-bar-lines'
7410 && (nlines
= tool_bar_lines_needed (f
),
7411 nlines
!= XFASTINT (w
->height
)))
7413 extern Lisp_Object Qtool_bar_lines
;
7415 int old_height
= XFASTINT (w
->height
);
7417 XSETFRAME (frame
, f
);
7418 clear_glyph_matrix (w
->desired_matrix
);
7419 Fmodify_frame_parameters (frame
,
7420 Fcons (Fcons (Qtool_bar_lines
,
7421 make_number (nlines
)),
7423 if (XFASTINT (w
->height
) != old_height
)
7424 fonts_changed_p
= 1;
7428 return change_height_p
;
7432 /* Get information about the tool-bar item which is displayed in GLYPH
7433 on frame F. Return in *PROP_IDX the index where tool-bar item
7434 properties start in F->tool_bar_items. Value is zero if
7435 GLYPH doesn't display a tool-bar item. */
7438 tool_bar_item_info (f
, glyph
, prop_idx
)
7440 struct glyph
*glyph
;
7446 /* Get the text property `menu-item' at pos. The value of that
7447 property is the start index of this item's properties in
7448 F->tool_bar_items. */
7449 prop
= Fget_text_property (make_number (glyph
->charpos
),
7450 Qmenu_item
, f
->current_tool_bar_string
);
7451 if (INTEGERP (prop
))
7453 *prop_idx
= XINT (prop
);
7462 #endif /* HAVE_WINDOW_SYSTEM */
7466 /************************************************************************
7467 Horizontal scrolling
7468 ************************************************************************/
7470 static int hscroll_window_tree
P_ ((Lisp_Object
));
7471 static int hscroll_windows
P_ ((Lisp_Object
));
7473 /* For all leaf windows in the window tree rooted at WINDOW, set their
7474 hscroll value so that PT is (i) visible in the window, and (ii) so
7475 that it is not within a certain margin at the window's left and
7476 right border. Value is non-zero if any window's hscroll has been
7480 hscroll_window_tree (window
)
7483 int hscrolled_p
= 0;
7485 while (WINDOWP (window
))
7487 struct window
*w
= XWINDOW (window
);
7489 if (WINDOWP (w
->hchild
))
7490 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
7491 else if (WINDOWP (w
->vchild
))
7492 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
7493 else if (w
->cursor
.vpos
>= 0)
7495 int hscroll_margin
, text_area_x
, text_area_y
;
7496 int text_area_width
, text_area_height
;
7497 struct glyph_row
*current_cursor_row
7498 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
7499 struct glyph_row
*desired_cursor_row
7500 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
7501 struct glyph_row
*cursor_row
7502 = (desired_cursor_row
->enabled_p
7503 ? desired_cursor_row
7504 : current_cursor_row
);
7506 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
,
7507 &text_area_width
, &text_area_height
);
7509 /* Scroll when cursor is inside this scroll margin. */
7510 hscroll_margin
= 5 * CANON_X_UNIT (XFRAME (w
->frame
));
7512 if ((XFASTINT (w
->hscroll
)
7513 && w
->cursor
.x
< hscroll_margin
)
7514 || (cursor_row
->enabled_p
7515 && cursor_row
->truncated_on_right_p
7516 && (w
->cursor
.x
> text_area_width
- hscroll_margin
)))
7520 struct buffer
*saved_current_buffer
;
7523 /* Find point in a display of infinite width. */
7524 saved_current_buffer
= current_buffer
;
7525 current_buffer
= XBUFFER (w
->buffer
);
7527 if (w
== XWINDOW (selected_window
))
7528 pt
= BUF_PT (current_buffer
);
7531 pt
= marker_position (w
->pointm
);
7532 pt
= max (BEGV
, pt
);
7536 /* Move iterator to pt starting at cursor_row->start in
7537 a line with infinite width. */
7538 init_to_row_start (&it
, w
, cursor_row
);
7539 it
.last_visible_x
= INFINITY
;
7540 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
7541 current_buffer
= saved_current_buffer
;
7543 /* Center cursor in window. */
7544 hscroll
= (max (0, it
.current_x
- text_area_width
/ 2)
7545 / CANON_X_UNIT (it
.f
));
7546 hscroll
= max (hscroll
, XFASTINT (w
->min_hscroll
));
7548 /* Don't call Fset_window_hscroll if value hasn't
7549 changed because it will prevent redisplay
7551 if (XFASTINT (w
->hscroll
) != hscroll
)
7553 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
7554 w
->hscroll
= make_number (hscroll
);
7563 /* Value is non-zero if hscroll of any leaf window has been changed. */
7568 /* Set hscroll so that cursor is visible and not inside horizontal
7569 scroll margins for all windows in the tree rooted at WINDOW. See
7570 also hscroll_window_tree above. Value is non-zero if any window's
7571 hscroll has been changed. If it has, desired matrices on the frame
7572 of WINDOW are cleared. */
7575 hscroll_windows (window
)
7580 if (automatic_hscrolling_p
)
7582 hscrolled_p
= hscroll_window_tree (window
);
7584 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
7593 /************************************************************************
7595 ************************************************************************/
7597 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
7598 to a non-zero value. This is sometimes handy to have in a debugger
7603 /* First and last unchanged row for try_window_id. */
7605 int debug_first_unchanged_at_end_vpos
;
7606 int debug_last_unchanged_at_beg_vpos
;
7608 /* Delta vpos and y. */
7610 int debug_dvpos
, debug_dy
;
7612 /* Delta in characters and bytes for try_window_id. */
7614 int debug_delta
, debug_delta_bytes
;
7616 /* Values of window_end_pos and window_end_vpos at the end of
7619 int debug_end_pos
, debug_end_vpos
;
7621 /* Append a string to W->desired_matrix->method. FMT is a printf
7622 format string. A1...A9 are a supplement for a variable-length
7623 argument list. If trace_redisplay_p is non-zero also printf the
7624 resulting string to stderr. */
7627 debug_method_add (w
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
7630 int a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
;
7633 char *method
= w
->desired_matrix
->method
;
7634 int len
= strlen (method
);
7635 int size
= sizeof w
->desired_matrix
->method
;
7636 int remaining
= size
- len
- 1;
7638 sprintf (buffer
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
7639 if (len
&& remaining
)
7645 strncpy (method
+ len
, buffer
, remaining
);
7647 if (trace_redisplay_p
)
7648 fprintf (stderr
, "%p (%s): %s\n",
7650 ((BUFFERP (w
->buffer
)
7651 && STRINGP (XBUFFER (w
->buffer
)->name
))
7652 ? (char *) XSTRING (XBUFFER (w
->buffer
)->name
)->data
7657 #endif /* GLYPH_DEBUG */
7660 /* This counter is used to clear the face cache every once in a while
7661 in redisplay_internal. It is incremented for each redisplay.
7662 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
7665 #define CLEAR_FACE_CACHE_COUNT 10000
7666 static int clear_face_cache_count
;
7668 /* Record the previous terminal frame we displayed. */
7670 static struct frame
*previous_terminal_frame
;
7672 /* Non-zero while redisplay_internal is in progress. */
7677 /* Value is non-zero if all changes in window W, which displays
7678 current_buffer, are in the text between START and END. START is a
7679 buffer position, END is given as a distance from Z. Used in
7680 redisplay_internal for display optimization. */
7683 text_outside_line_unchanged_p (w
, start
, end
)
7687 int unchanged_p
= 1;
7689 /* If text or overlays have changed, see where. */
7690 if (XFASTINT (w
->last_modified
) < MODIFF
7691 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
7693 /* Gap in the line? */
7694 if (GPT
< start
|| Z
- GPT
< end
)
7697 /* Changes start in front of the line, or end after it? */
7699 && (BEG_UNCHANGED
< start
- 1
7700 || END_UNCHANGED
< end
))
7703 /* If selective display, can't optimize if changes start at the
7704 beginning of the line. */
7706 && INTEGERP (current_buffer
->selective_display
)
7707 && XINT (current_buffer
->selective_display
) > 0
7708 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
7716 /* Do a frame update, taking possible shortcuts into account. This is
7717 the main external entry point for redisplay.
7719 If the last redisplay displayed an echo area message and that message
7720 is no longer requested, we clear the echo area or bring back the
7721 mini-buffer if that is in use. */
7726 redisplay_internal (0);
7729 /* Return 1 if point moved out of or into a composition. Otherwise
7730 return 0. PREV_BUF and PREV_PT are the last point buffer and
7731 position. BUF and PT are the current point buffer and position. */
7734 check_point_in_composition (prev_buf
, prev_pt
, buf
, pt
)
7735 struct buffer
*prev_buf
, *buf
;
7742 XSETBUFFER (buffer
, buf
);
7743 /* Check a composition at the last point if point moved within the
7745 if (prev_buf
== buf
)
7748 /* Point didn't move. */
7751 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
7752 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
7753 && COMPOSITION_VALID_P (start
, end
, prop
)
7754 && start
< prev_pt
&& end
> prev_pt
)
7755 /* The last point was within the composition. Return 1 iff
7756 point moved out of the composition. */
7757 return (pt
<= start
|| pt
>= end
);
7760 /* Check a composition at the current point. */
7761 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
7762 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
7763 && COMPOSITION_VALID_P (start
, end
, prop
)
7764 && start
< pt
&& end
> pt
);
7767 /* Reconsider the setting of B->clip_changed which is displayed
7771 reconsider_clip_changes (w
, b
)
7775 if (b
->prevent_redisplay_optimizations_p
)
7776 b
->clip_changed
= 1;
7777 else if (b
->clip_changed
7778 && !NILP (w
->window_end_valid
)
7779 && w
->current_matrix
->buffer
== b
7780 && w
->current_matrix
->zv
== BUF_ZV (b
)
7781 && w
->current_matrix
->begv
== BUF_BEGV (b
))
7782 b
->clip_changed
= 0;
7784 /* If display wasn't paused, and W is not a tool bar window, see if
7785 point has been moved into or out of a composition. In that case,
7786 we set b->clip_changed to 1 to force updating the screen. If
7787 b->clip_changed has already been set to 1, we can skip this
7789 if (!b
->clip_changed
7790 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
7794 if (w
== XWINDOW (selected_window
))
7795 pt
= BUF_PT (current_buffer
);
7797 pt
= marker_position (w
->pointm
);
7799 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
7800 || pt
!= XINT (w
->last_point
))
7801 && check_point_in_composition (w
->current_matrix
->buffer
,
7802 XINT (w
->last_point
),
7803 XBUFFER (w
->buffer
), pt
))
7804 b
->clip_changed
= 1;
7809 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay is not in
7810 response to any user action; therefore, we should preserve the echo
7811 area. (Actually, our caller does that job.) Perhaps in the future
7812 avoid recentering windows if it is not necessary; currently that
7813 causes some problems. */
7816 redisplay_internal (preserve_echo_area
)
7817 int preserve_echo_area
;
7819 struct window
*w
= XWINDOW (selected_window
);
7820 struct frame
*f
= XFRAME (w
->frame
);
7822 int must_finish
= 0;
7823 struct text_pos tlbufpos
, tlendpos
;
7824 int number_of_visible_frames
;
7826 struct frame
*sf
= SELECTED_FRAME ();
7828 /* Non-zero means redisplay has to consider all windows on all
7829 frames. Zero means, only selected_window is considered. */
7830 int consider_all_windows_p
;
7832 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
7834 /* No redisplay if running in batch mode or frame is not yet fully
7835 initialized, or redisplay is explicitly turned off by setting
7836 Vinhibit_redisplay. */
7838 || !NILP (Vinhibit_redisplay
)
7839 || !f
->glyphs_initialized_p
)
7842 /* The flag redisplay_performed_directly_p is set by
7843 direct_output_for_insert when it already did the whole screen
7844 update necessary. */
7845 if (redisplay_performed_directly_p
)
7847 redisplay_performed_directly_p
= 0;
7848 if (!hscroll_windows (selected_window
))
7852 #ifdef USE_X_TOOLKIT
7853 if (popup_activated ())
7857 /* I don't think this happens but let's be paranoid. */
7861 /* Record a function that resets redisplaying_p to its old value
7862 when we leave this function. */
7863 count
= BINDING_STACK_SIZE ();
7864 record_unwind_protect (unwind_redisplay
, make_number (redisplaying_p
));
7869 reconsider_clip_changes (w
, current_buffer
);
7871 /* If new fonts have been loaded that make a glyph matrix adjustment
7872 necessary, do it. */
7873 if (fonts_changed_p
)
7875 adjust_glyphs (NULL
);
7876 ++windows_or_buffers_changed
;
7877 fonts_changed_p
= 0;
7880 if (! FRAME_WINDOW_P (sf
)
7881 && previous_terminal_frame
!= sf
)
7883 /* Since frames on an ASCII terminal share the same display
7884 area, displaying a different frame means redisplay the whole
7886 windows_or_buffers_changed
++;
7887 SET_FRAME_GARBAGED (sf
);
7888 XSETFRAME (Vterminal_frame
, sf
);
7890 previous_terminal_frame
= sf
;
7892 /* Set the visible flags for all frames. Do this before checking
7893 for resized or garbaged frames; they want to know if their frames
7894 are visible. See the comment in frame.h for
7895 FRAME_SAMPLE_VISIBILITY. */
7897 Lisp_Object tail
, frame
;
7899 number_of_visible_frames
= 0;
7901 FOR_EACH_FRAME (tail
, frame
)
7903 struct frame
*f
= XFRAME (frame
);
7905 FRAME_SAMPLE_VISIBILITY (f
);
7906 if (FRAME_VISIBLE_P (f
))
7907 ++number_of_visible_frames
;
7908 clear_desired_matrices (f
);
7912 /* Notice any pending interrupt request to change frame size. */
7913 do_pending_window_change (1);
7915 /* Clear frames marked as garbaged. */
7917 clear_garbaged_frames ();
7919 /* Build menubar and tool-bar items. */
7920 prepare_menu_bars ();
7922 if (windows_or_buffers_changed
)
7923 update_mode_lines
++;
7925 /* Detect case that we need to write or remove a star in the mode line. */
7926 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
7928 w
->update_mode_line
= Qt
;
7929 if (buffer_shared
> 1)
7930 update_mode_lines
++;
7933 /* If %c is in the mode line, update it if needed. */
7934 if (!NILP (w
->column_number_displayed
)
7935 /* This alternative quickly identifies a common case
7936 where no change is needed. */
7937 && !(PT
== XFASTINT (w
->last_point
)
7938 && XFASTINT (w
->last_modified
) >= MODIFF
7939 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
7940 && XFASTINT (w
->column_number_displayed
) != current_column ())
7941 w
->update_mode_line
= Qt
;
7943 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
7945 /* The variable buffer_shared is set in redisplay_window and
7946 indicates that we redisplay a buffer in different windows. See
7948 consider_all_windows_p
= update_mode_lines
|| buffer_shared
> 1;
7950 /* If specs for an arrow have changed, do thorough redisplay
7951 to ensure we remove any arrow that should no longer exist. */
7952 if (! EQ (COERCE_MARKER (Voverlay_arrow_position
), last_arrow_position
)
7953 || ! EQ (Voverlay_arrow_string
, last_arrow_string
))
7954 consider_all_windows_p
= windows_or_buffers_changed
= 1;
7956 /* Normally the message* functions will have already displayed and
7957 updated the echo area, but the frame may have been trashed, or
7958 the update may have been preempted, so display the echo area
7959 again here. Checking both message buffers captures the case that
7960 the echo area should be cleared. */
7961 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
7963 int window_height_changed_p
= echo_area_display (0);
7966 if (fonts_changed_p
)
7968 else if (window_height_changed_p
)
7970 consider_all_windows_p
= 1;
7971 ++update_mode_lines
;
7972 ++windows_or_buffers_changed
;
7974 /* If window configuration was changed, frames may have been
7975 marked garbaged. Clear them or we will experience
7976 surprises wrt scrolling. */
7978 clear_garbaged_frames ();
7981 else if (EQ (selected_window
, minibuf_window
)
7982 && (current_buffer
->clip_changed
7983 || XFASTINT (w
->last_modified
) < MODIFF
7984 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
7985 && resize_mini_window (w
, 0))
7987 /* Resized active mini-window to fit the size of what it is
7988 showing if its contents might have changed. */
7990 consider_all_windows_p
= 1;
7991 ++windows_or_buffers_changed
;
7992 ++update_mode_lines
;
7994 /* If window configuration was changed, frames may have been
7995 marked garbaged. Clear them or we will experience
7996 surprises wrt scrolling. */
7998 clear_garbaged_frames ();
8002 /* If showing the region, and mark has changed, we must redisplay
8003 the whole window. The assignment to this_line_start_pos prevents
8004 the optimization directly below this if-statement. */
8005 if (((!NILP (Vtransient_mark_mode
)
8006 && !NILP (XBUFFER (w
->buffer
)->mark_active
))
8007 != !NILP (w
->region_showing
))
8008 || (!NILP (w
->region_showing
)
8009 && !EQ (w
->region_showing
,
8010 Fmarker_position (XBUFFER (w
->buffer
)->mark
))))
8011 CHARPOS (this_line_start_pos
) = 0;
8013 /* Optimize the case that only the line containing the cursor in the
8014 selected window has changed. Variables starting with this_ are
8015 set in display_line and record information about the line
8016 containing the cursor. */
8017 tlbufpos
= this_line_start_pos
;
8018 tlendpos
= this_line_end_pos
;
8019 if (!consider_all_windows_p
8020 && CHARPOS (tlbufpos
) > 0
8021 && NILP (w
->update_mode_line
)
8022 && !current_buffer
->clip_changed
8023 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
8024 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
8025 /* Make sure recorded data applies to current buffer, etc. */
8026 && this_line_buffer
== current_buffer
8027 && current_buffer
== XBUFFER (w
->buffer
)
8028 && NILP (w
->force_start
)
8029 /* Point must be on the line that we have info recorded about. */
8030 && PT
>= CHARPOS (tlbufpos
)
8031 && PT
<= Z
- CHARPOS (tlendpos
)
8032 /* All text outside that line, including its final newline,
8033 must be unchanged */
8034 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
8035 CHARPOS (tlendpos
)))
8037 if (CHARPOS (tlbufpos
) > BEGV
8038 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
8039 && (CHARPOS (tlbufpos
) == ZV
8040 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
8041 /* Former continuation line has disappeared by becoming empty */
8043 else if (XFASTINT (w
->last_modified
) < MODIFF
8044 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
8045 || MINI_WINDOW_P (w
))
8047 /* We have to handle the case of continuation around a
8048 wide-column character (See the comment in indent.c around
8051 For instance, in the following case:
8053 -------- Insert --------
8054 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
8055 J_I_ ==> J_I_ `^^' are cursors.
8059 As we have to redraw the line above, we should goto cancel. */
8062 int line_height_before
= this_line_pixel_height
;
8064 /* Note that start_display will handle the case that the
8065 line starting at tlbufpos is a continuation lines. */
8066 start_display (&it
, w
, tlbufpos
);
8068 /* Implementation note: It this still necessary? */
8069 if (it
.current_x
!= this_line_start_x
)
8072 TRACE ((stderr
, "trying display optimization 1\n"));
8073 w
->cursor
.vpos
= -1;
8074 overlay_arrow_seen
= 0;
8075 it
.vpos
= this_line_vpos
;
8076 it
.current_y
= this_line_y
;
8077 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
8080 /* If line contains point, is not continued,
8081 and ends at same distance from eob as before, we win */
8082 if (w
->cursor
.vpos
>= 0
8083 /* Line is not continued, otherwise this_line_start_pos
8084 would have been set to 0 in display_line. */
8085 && CHARPOS (this_line_start_pos
)
8086 /* Line ends as before. */
8087 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
8088 /* Line has same height as before. Otherwise other lines
8089 would have to be shifted up or down. */
8090 && this_line_pixel_height
== line_height_before
)
8092 /* If this is not the window's last line, we must adjust
8093 the charstarts of the lines below. */
8094 if (it
.current_y
< it
.last_visible_y
)
8096 struct glyph_row
*row
8097 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
8098 int delta
, delta_bytes
;
8100 if (Z
- CHARPOS (tlendpos
) == ZV
)
8102 /* This line ends at end of (accessible part of)
8103 buffer. There is no newline to count. */
8105 - CHARPOS (tlendpos
)
8106 - MATRIX_ROW_START_CHARPOS (row
));
8107 delta_bytes
= (Z_BYTE
8108 - BYTEPOS (tlendpos
)
8109 - MATRIX_ROW_START_BYTEPOS (row
));
8113 /* This line ends in a newline. Must take
8114 account of the newline and the rest of the
8115 text that follows. */
8117 - CHARPOS (tlendpos
)
8118 - MATRIX_ROW_START_CHARPOS (row
));
8119 delta_bytes
= (Z_BYTE
8120 - BYTEPOS (tlendpos
)
8121 - MATRIX_ROW_START_BYTEPOS (row
));
8124 increment_matrix_positions (w
->current_matrix
,
8126 w
->current_matrix
->nrows
,
8127 delta
, delta_bytes
);
8130 /* If this row displays text now but previously didn't,
8131 or vice versa, w->window_end_vpos may have to be
8133 if ((it
.glyph_row
- 1)->displays_text_p
)
8135 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
8136 XSETINT (w
->window_end_vpos
, this_line_vpos
);
8138 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
8139 && this_line_vpos
> 0)
8140 XSETINT (w
->window_end_vpos
, this_line_vpos
- 1);
8141 w
->window_end_valid
= Qnil
;
8143 /* Update hint: No need to try to scroll in update_window. */
8144 w
->desired_matrix
->no_scrolling_p
= 1;
8147 *w
->desired_matrix
->method
= 0;
8148 debug_method_add (w
, "optimization 1");
8155 else if (/* Cursor position hasn't changed. */
8156 PT
== XFASTINT (w
->last_point
)
8157 /* Make sure the cursor was last displayed
8158 in this window. Otherwise we have to reposition it. */
8159 && 0 <= w
->cursor
.vpos
8160 && XINT (w
->height
) > w
->cursor
.vpos
)
8164 do_pending_window_change (1);
8166 /* We used to always goto end_of_redisplay here, but this
8167 isn't enough if we have a blinking cursor. */
8168 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
8169 goto end_of_redisplay
;
8173 /* If highlighting the region, or if the cursor is in the echo area,
8174 then we can't just move the cursor. */
8175 else if (! (!NILP (Vtransient_mark_mode
)
8176 && !NILP (current_buffer
->mark_active
))
8177 && (EQ (selected_window
, current_buffer
->last_selected_window
)
8178 || highlight_nonselected_windows
)
8179 && NILP (w
->region_showing
)
8180 && NILP (Vshow_trailing_whitespace
)
8181 && !cursor_in_echo_area
)
8184 struct glyph_row
*row
;
8186 /* Skip from tlbufpos to PT and see where it is. Note that
8187 PT may be in invisible text. If so, we will end at the
8188 next visible position. */
8189 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
8190 NULL
, DEFAULT_FACE_ID
);
8191 it
.current_x
= this_line_start_x
;
8192 it
.current_y
= this_line_y
;
8193 it
.vpos
= this_line_vpos
;
8195 /* The call to move_it_to stops in front of PT, but
8196 moves over before-strings. */
8197 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
8199 if (it
.vpos
== this_line_vpos
8200 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
8203 xassert (this_line_vpos
== it
.vpos
);
8204 xassert (this_line_y
== it
.current_y
);
8205 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
8213 /* Text changed drastically or point moved off of line. */
8214 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
8217 CHARPOS (this_line_start_pos
) = 0;
8218 consider_all_windows_p
|= buffer_shared
> 1;
8219 ++clear_face_cache_count
;
8222 /* Build desired matrices, and update the display. If
8223 consider_all_windows_p is non-zero, do it for all windows on all
8224 frames. Otherwise do it for selected_window, only. */
8226 if (consider_all_windows_p
)
8228 Lisp_Object tail
, frame
;
8230 /* Clear the face cache eventually. */
8231 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
8233 clear_face_cache (0);
8234 clear_face_cache_count
= 0;
8237 /* Recompute # windows showing selected buffer. This will be
8238 incremented each time such a window is displayed. */
8241 FOR_EACH_FRAME (tail
, frame
)
8243 struct frame
*f
= XFRAME (frame
);
8245 if (FRAME_WINDOW_P (f
) || f
== sf
)
8247 /* Mark all the scroll bars to be removed; we'll redeem
8248 the ones we want when we redisplay their windows. */
8249 if (condemn_scroll_bars_hook
)
8250 condemn_scroll_bars_hook (f
);
8252 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
8253 redisplay_windows (FRAME_ROOT_WINDOW (f
));
8255 /* Any scroll bars which redisplay_windows should have
8256 nuked should now go away. */
8257 if (judge_scroll_bars_hook
)
8258 judge_scroll_bars_hook (f
);
8260 /* If fonts changed, display again. */
8261 if (fonts_changed_p
)
8264 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
8266 /* See if we have to hscroll. */
8267 if (hscroll_windows (f
->root_window
))
8270 /* Prevent various kinds of signals during display
8271 update. stdio is not robust about handling
8272 signals, which can cause an apparent I/O
8274 if (interrupt_input
)
8278 /* Update the display. */
8279 set_window_update_flags (XWINDOW (f
->root_window
), 1);
8280 pause
|= update_frame (f
, 0, 0);
8284 mark_window_display_accurate (f
->root_window
, 1);
8285 if (frame_up_to_date_hook
)
8286 frame_up_to_date_hook (f
);
8291 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
8293 Lisp_Object mini_window
;
8294 struct frame
*mini_frame
;
8296 redisplay_window (selected_window
, 1);
8298 /* Compare desired and current matrices, perform output. */
8301 /* If fonts changed, display again. */
8302 if (fonts_changed_p
)
8305 /* Prevent various kinds of signals during display update.
8306 stdio is not robust about handling signals,
8307 which can cause an apparent I/O error. */
8308 if (interrupt_input
)
8312 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
8314 if (hscroll_windows (selected_window
))
8317 XWINDOW (selected_window
)->must_be_updated_p
= 1;
8318 pause
= update_frame (sf
, 0, 0);
8321 /* We may have called echo_area_display at the top of this
8322 function. If the echo area is on another frame, that may
8323 have put text on a frame other than the selected one, so the
8324 above call to update_frame would not have caught it. Catch
8326 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8327 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8329 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
8331 XWINDOW (mini_window
)->must_be_updated_p
= 1;
8332 pause
|= update_frame (mini_frame
, 0, 0);
8333 if (!pause
&& hscroll_windows (mini_window
))
8338 /* If display was paused because of pending input, make sure we do a
8339 thorough update the next time. */
8342 /* Prevent the optimization at the beginning of
8343 redisplay_internal that tries a single-line update of the
8344 line containing the cursor in the selected window. */
8345 CHARPOS (this_line_start_pos
) = 0;
8347 /* Let the overlay arrow be updated the next time. */
8348 if (!NILP (last_arrow_position
))
8350 last_arrow_position
= Qt
;
8351 last_arrow_string
= Qt
;
8354 /* If we pause after scrolling, some rows in the current
8355 matrices of some windows are not valid. */
8356 if (!WINDOW_FULL_WIDTH_P (w
)
8357 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
8358 update_mode_lines
= 1;
8361 /* Now text on frame agrees with windows, so put info into the
8362 windows for partial redisplay to follow. */
8365 register struct buffer
*b
= XBUFFER (w
->buffer
);
8367 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
8368 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
8369 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
8370 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
8372 if (consider_all_windows_p
)
8373 mark_window_display_accurate (FRAME_ROOT_WINDOW (sf
), 1);
8376 XSETFASTINT (w
->last_point
, BUF_PT (b
));
8377 w
->last_cursor
= w
->cursor
;
8378 w
->last_cursor_off_p
= w
->cursor_off_p
;
8380 b
->clip_changed
= 0;
8381 b
->prevent_redisplay_optimizations_p
= 0;
8382 w
->update_mode_line
= Qnil
;
8383 XSETFASTINT (w
->last_modified
, BUF_MODIFF (b
));
8384 XSETFASTINT (w
->last_overlay_modified
, BUF_OVERLAY_MODIFF (b
));
8386 = (BUF_MODIFF (XBUFFER (w
->buffer
)) > BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
8389 /* Record if we are showing a region, so can make sure to
8390 update it fully at next redisplay. */
8391 w
->region_showing
= (!NILP (Vtransient_mark_mode
)
8392 && (EQ (selected_window
,
8393 current_buffer
->last_selected_window
)
8394 || highlight_nonselected_windows
)
8395 && !NILP (XBUFFER (w
->buffer
)->mark_active
)
8396 ? Fmarker_position (XBUFFER (w
->buffer
)->mark
)
8399 w
->window_end_valid
= w
->buffer
;
8400 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
8401 last_arrow_string
= Voverlay_arrow_string
;
8402 if (frame_up_to_date_hook
!= 0)
8403 (*frame_up_to_date_hook
) (sf
);
8405 w
->current_matrix
->buffer
= b
;
8406 w
->current_matrix
->begv
= BUF_BEGV (b
);
8407 w
->current_matrix
->zv
= BUF_ZV (b
);
8410 update_mode_lines
= 0;
8411 windows_or_buffers_changed
= 0;
8414 /* Start SIGIO interrupts coming again. Having them off during the
8415 code above makes it less likely one will discard output, but not
8416 impossible, since there might be stuff in the system buffer here.
8417 But it is much hairier to try to do anything about that. */
8418 if (interrupt_input
)
8422 /* If a frame has become visible which was not before, redisplay
8423 again, so that we display it. Expose events for such a frame
8424 (which it gets when becoming visible) don't call the parts of
8425 redisplay constructing glyphs, so simply exposing a frame won't
8426 display anything in this case. So, we have to display these
8427 frames here explicitly. */
8430 Lisp_Object tail
, frame
;
8433 FOR_EACH_FRAME (tail
, frame
)
8435 int this_is_visible
= 0;
8437 if (XFRAME (frame
)->visible
)
8438 this_is_visible
= 1;
8439 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
8440 if (XFRAME (frame
)->visible
)
8441 this_is_visible
= 1;
8443 if (this_is_visible
)
8447 if (new_count
!= number_of_visible_frames
)
8448 windows_or_buffers_changed
++;
8451 /* Change frame size now if a change is pending. */
8452 do_pending_window_change (1);
8454 /* If we just did a pending size change, or have additional
8455 visible frames, redisplay again. */
8456 if (windows_or_buffers_changed
&& !pause
)
8461 unbind_to (count
, Qnil
);
8465 /* Redisplay, but leave alone any recent echo area message unless
8466 another message has been requested in its place.
8468 This is useful in situations where you need to redisplay but no
8469 user action has occurred, making it inappropriate for the message
8470 area to be cleared. See tracking_off and
8471 wait_reading_process_input for examples of these situations. */
8474 redisplay_preserve_echo_area ()
8476 if (!NILP (echo_area_buffer
[1]))
8478 /* We have a previously displayed message, but no current
8479 message. Redisplay the previous message. */
8480 display_last_displayed_message_p
= 1;
8481 redisplay_internal (1);
8482 display_last_displayed_message_p
= 0;
8485 redisplay_internal (1);
8489 /* Function registered with record_unwind_protect in
8490 redisplay_internal. Clears the flag indicating that a redisplay is
8494 unwind_redisplay (old_redisplaying_p
)
8495 Lisp_Object old_redisplaying_p
;
8497 redisplaying_p
= XFASTINT (old_redisplaying_p
);
8502 /* Mark the display of windows in the window tree rooted at WINDOW as
8503 accurate or inaccurate. If FLAG is non-zero mark display of WINDOW
8504 as accurate. If FLAG is zero arrange for WINDOW to be redisplayed
8505 the next time redisplay_internal is called. */
8508 mark_window_display_accurate (window
, accurate_p
)
8514 for (; !NILP (window
); window
= w
->next
)
8516 w
= XWINDOW (window
);
8518 if (BUFFERP (w
->buffer
))
8520 struct buffer
*b
= XBUFFER (w
->buffer
);
8522 XSETFASTINT (w
->last_modified
,
8523 accurate_p
? BUF_MODIFF (b
) : 0);
8524 XSETFASTINT (w
->last_overlay_modified
,
8525 accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0);
8526 w
->last_had_star
= (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
)
8529 #if 0 /* I don't think this is necessary because display_line does it.
8531 /* Record if we are showing a region, so can make sure to
8532 update it fully at next redisplay. */
8534 = (!NILP (Vtransient_mark_mode
)
8535 && (w
== XWINDOW (current_buffer
->last_selected_window
)
8536 || highlight_nonselected_windows
)
8537 && (!NILP (b
->mark_active
)
8538 ? Fmarker_position (b
->mark
)
8544 b
->clip_changed
= 0;
8545 b
->prevent_redisplay_optimizations_p
= 0;
8546 w
->current_matrix
->buffer
= b
;
8547 w
->current_matrix
->begv
= BUF_BEGV (b
);
8548 w
->current_matrix
->zv
= BUF_ZV (b
);
8549 w
->last_cursor
= w
->cursor
;
8550 w
->last_cursor_off_p
= w
->cursor_off_p
;
8551 if (w
== XWINDOW (selected_window
))
8552 w
->last_point
= make_number (BUF_PT (b
));
8554 w
->last_point
= make_number (XMARKER (w
->pointm
)->charpos
);
8558 w
->window_end_valid
= w
->buffer
;
8559 w
->update_mode_line
= Qnil
;
8561 if (!NILP (w
->vchild
))
8562 mark_window_display_accurate (w
->vchild
, accurate_p
);
8563 if (!NILP (w
->hchild
))
8564 mark_window_display_accurate (w
->hchild
, accurate_p
);
8569 last_arrow_position
= COERCE_MARKER (Voverlay_arrow_position
);
8570 last_arrow_string
= Voverlay_arrow_string
;
8574 /* Force a thorough redisplay the next time by setting
8575 last_arrow_position and last_arrow_string to t, which is
8576 unequal to any useful value of Voverlay_arrow_... */
8577 last_arrow_position
= Qt
;
8578 last_arrow_string
= Qt
;
8583 /* Return value in display table DP (Lisp_Char_Table *) for character
8584 C. Since a display table doesn't have any parent, we don't have to
8585 follow parent. Do not call this function directly but use the
8586 macro DISP_CHAR_VECTOR. */
8589 disp_char_vector (dp
, c
)
8590 struct Lisp_Char_Table
*dp
;
8596 if (SINGLE_BYTE_CHAR_P (c
))
8597 return (dp
->contents
[c
]);
8599 SPLIT_CHAR (c
, code
[0], code
[1], code
[2]);
8602 else if (code
[2] < 32)
8605 /* Here, the possible range of code[0] (== charset ID) is
8606 128..max_charset. Since the top level char table contains data
8607 for multibyte characters after 256th element, we must increment
8608 code[0] by 128 to get a correct index. */
8610 code
[3] = -1; /* anchor */
8612 for (i
= 0; code
[i
] >= 0; i
++, dp
= XCHAR_TABLE (val
))
8614 val
= dp
->contents
[code
[i
]];
8615 if (!SUB_CHAR_TABLE_P (val
))
8616 return (NILP (val
) ? dp
->defalt
: val
);
8619 /* Here, val is a sub char table. We return the default value of
8621 return (dp
->defalt
);
8626 /***********************************************************************
8628 ***********************************************************************/
8630 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
8633 redisplay_windows (window
)
8636 while (!NILP (window
))
8638 struct window
*w
= XWINDOW (window
);
8640 if (!NILP (w
->hchild
))
8641 redisplay_windows (w
->hchild
);
8642 else if (!NILP (w
->vchild
))
8643 redisplay_windows (w
->vchild
);
8645 redisplay_window (window
, 0);
8652 /* Set cursor position of W. PT is assumed to be displayed in ROW.
8653 DELTA is the number of bytes by which positions recorded in ROW
8654 differ from current buffer positions. */
8657 set_cursor_from_row (w
, row
, matrix
, delta
, delta_bytes
, dy
, dvpos
)
8659 struct glyph_row
*row
;
8660 struct glyph_matrix
*matrix
;
8661 int delta
, delta_bytes
, dy
, dvpos
;
8663 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
8664 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
8666 int pt_old
= PT
- delta
;
8668 /* Skip over glyphs not having an object at the start of the row.
8669 These are special glyphs like truncation marks on terminal
8671 if (row
->displays_text_p
)
8673 && INTEGERP (glyph
->object
)
8674 && glyph
->charpos
< 0)
8676 x
+= glyph
->pixel_width
;
8681 && !INTEGERP (glyph
->object
)
8682 && (!BUFFERP (glyph
->object
)
8683 || glyph
->charpos
< pt_old
))
8685 x
+= glyph
->pixel_width
;
8689 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
8691 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
8692 w
->cursor
.y
= row
->y
+ dy
;
8694 if (w
== XWINDOW (selected_window
))
8696 if (!row
->continued_p
8697 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
8700 this_line_buffer
= XBUFFER (w
->buffer
);
8702 CHARPOS (this_line_start_pos
)
8703 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
8704 BYTEPOS (this_line_start_pos
)
8705 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
8707 CHARPOS (this_line_end_pos
)
8708 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
8709 BYTEPOS (this_line_end_pos
)
8710 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
8712 this_line_y
= w
->cursor
.y
;
8713 this_line_pixel_height
= row
->height
;
8714 this_line_vpos
= w
->cursor
.vpos
;
8715 this_line_start_x
= row
->x
;
8718 CHARPOS (this_line_start_pos
) = 0;
8723 /* Run window scroll functions, if any, for WINDOW with new window
8724 start STARTP. Sets the window start of WINDOW to that position.
8726 We assume that the window's buffer is really current. */
8728 static INLINE
struct text_pos
8729 run_window_scroll_functions (window
, startp
)
8731 struct text_pos startp
;
8733 struct window
*w
= XWINDOW (window
);
8734 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
8736 if (current_buffer
!= XBUFFER (w
->buffer
))
8739 if (!NILP (Vwindow_scroll_functions
))
8741 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
8742 make_number (CHARPOS (startp
)));
8743 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
8744 /* In case the hook functions switch buffers. */
8745 if (current_buffer
!= XBUFFER (w
->buffer
))
8746 set_buffer_internal_1 (XBUFFER (w
->buffer
));
8753 /* Modify the desired matrix of window W and W->vscroll so that the
8754 line containing the cursor is fully visible. */
8757 make_cursor_line_fully_visible (w
)
8760 struct glyph_matrix
*matrix
;
8761 struct glyph_row
*row
;
8762 int window_height
, header_line_height
;
8764 /* It's not always possible to find the cursor, e.g, when a window
8765 is full of overlay strings. Don't do anything in that case. */
8766 if (w
->cursor
.vpos
< 0)
8769 matrix
= w
->desired_matrix
;
8770 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
8772 /* If the cursor row is not partially visible, there's nothing
8774 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (row
))
8777 /* If the row the cursor is in is taller than the window's height,
8778 it's not clear what to do, so do nothing. */
8779 window_height
= window_box_height (w
);
8780 if (row
->height
>= window_height
)
8783 if (MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w
, row
))
8785 int dy
= row
->height
- row
->visible_height
;
8788 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
8790 else /* MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row)) */
8792 int dy
= - (row
->height
- row
->visible_height
);
8795 shift_glyph_matrix (w
, matrix
, 0, matrix
->nrows
, dy
);
8798 /* When we change the cursor y-position of the selected window,
8799 change this_line_y as well so that the display optimization for
8800 the cursor line of the selected window in redisplay_internal uses
8801 the correct y-position. */
8802 if (w
== XWINDOW (selected_window
))
8803 this_line_y
= w
->cursor
.y
;
8807 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
8808 non-zero means only WINDOW is redisplayed in redisplay_internal.
8809 TEMP_SCROLL_STEP has the same meaning as scroll_step, and is used
8810 in redisplay_window to bring a partially visible line into view in
8811 the case that only the cursor has moved.
8815 1 if scrolling succeeded
8817 0 if scrolling didn't find point.
8819 -1 if new fonts have been loaded so that we must interrupt
8820 redisplay, adjust glyph matrices, and try again. */
8823 try_scrolling (window
, just_this_one_p
, scroll_conservatively
,
8824 scroll_step
, temp_scroll_step
)
8826 int just_this_one_p
;
8827 int scroll_conservatively
, scroll_step
;
8828 int temp_scroll_step
;
8830 struct window
*w
= XWINDOW (window
);
8831 struct frame
*f
= XFRAME (w
->frame
);
8832 struct text_pos scroll_margin_pos
;
8833 struct text_pos pos
;
8834 struct text_pos startp
;
8836 Lisp_Object window_end
;
8837 int this_scroll_margin
;
8841 int amount_to_scroll
= 0;
8842 Lisp_Object aggressive
;
8846 debug_method_add (w
, "try_scrolling");
8849 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
8851 /* Compute scroll margin height in pixels. We scroll when point is
8852 within this distance from the top or bottom of the window. */
8853 if (scroll_margin
> 0)
8855 this_scroll_margin
= min (scroll_margin
, XINT (w
->height
) / 4);
8856 this_scroll_margin
*= CANON_Y_UNIT (f
);
8859 this_scroll_margin
= 0;
8861 /* Compute how much we should try to scroll maximally to bring point
8863 if (scroll_step
|| scroll_conservatively
|| temp_scroll_step
)
8864 scroll_max
= max (scroll_step
,
8865 max (scroll_conservatively
, temp_scroll_step
));
8866 else if (NUMBERP (current_buffer
->scroll_down_aggressively
)
8867 || NUMBERP (current_buffer
->scroll_up_aggressively
))
8868 /* We're trying to scroll because of aggressive scrolling
8869 but no scroll_step is set. Choose an arbitrary one. Maybe
8870 there should be a variable for this. */
8874 scroll_max
*= CANON_Y_UNIT (f
);
8876 /* Decide whether we have to scroll down. Start at the window end
8877 and move this_scroll_margin up to find the position of the scroll
8879 window_end
= Fwindow_end (window
, Qt
);
8880 CHARPOS (scroll_margin_pos
) = XINT (window_end
);
8881 BYTEPOS (scroll_margin_pos
) = CHAR_TO_BYTE (CHARPOS (scroll_margin_pos
));
8882 if (this_scroll_margin
)
8884 start_display (&it
, w
, scroll_margin_pos
);
8885 move_it_vertically (&it
, - this_scroll_margin
);
8886 scroll_margin_pos
= it
.current
.pos
;
8889 if (PT
>= CHARPOS (scroll_margin_pos
))
8896 /* Point is in the scroll margin at the bottom of the window, or
8897 below. Compute a new window start that makes point visible. */
8899 /* Compute the distance from the scroll margin to PT.
8900 Give up if the distance is greater than scroll_max. */
8901 start_display (&it
, w
, scroll_margin_pos
);
8903 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
8904 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
8905 #if 0 /* Taking the line's height into account here looks wrong. */
8906 line_height
= (it
.max_ascent
+ it
.max_descent
8907 ? it
.max_ascent
+ it
.max_descent
8909 dy
= it
.current_y
+ line_height
- y0
;
8911 /* With a scroll_margin of 0, scroll_margin_pos is at the window
8912 end, which is one line below the window. The iterator's
8913 current_y will be same as y0 in that case, but we have to
8914 scroll a line to make PT visible. That's the reason why 1 is
8916 dy
= 1 + it
.current_y
- y0
;
8919 if (dy
> scroll_max
)
8922 /* Move the window start down. If scrolling conservatively,
8923 move it just enough down to make point visible. If
8924 scroll_step is set, move it down by scroll_step. */
8925 start_display (&it
, w
, startp
);
8927 if (scroll_conservatively
)
8929 max (dy
, CANON_Y_UNIT (f
) * max (scroll_step
, temp_scroll_step
));
8930 else if (scroll_step
|| temp_scroll_step
)
8931 amount_to_scroll
= scroll_max
;
8934 aggressive
= current_buffer
->scroll_down_aggressively
;
8935 height
= (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
)
8936 - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
8937 if (NUMBERP (aggressive
))
8938 amount_to_scroll
= XFLOATINT (aggressive
) * height
;
8941 if (amount_to_scroll
<= 0)
8944 move_it_vertically (&it
, amount_to_scroll
);
8945 startp
= it
.current
.pos
;
8949 /* See if point is inside the scroll margin at the top of the
8951 scroll_margin_pos
= startp
;
8952 if (this_scroll_margin
)
8954 start_display (&it
, w
, startp
);
8955 move_it_vertically (&it
, this_scroll_margin
);
8956 scroll_margin_pos
= it
.current
.pos
;
8959 if (PT
< CHARPOS (scroll_margin_pos
))
8961 /* Point is in the scroll margin at the top of the window or
8962 above what is displayed in the window. */
8965 /* Compute the vertical distance from PT to the scroll
8966 margin position. Give up if distance is greater than
8968 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
8969 start_display (&it
, w
, pos
);
8971 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
8972 it
.last_visible_y
, -1,
8973 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
8974 dy
= it
.current_y
- y0
;
8975 if (dy
> scroll_max
)
8978 /* Compute new window start. */
8979 start_display (&it
, w
, startp
);
8981 if (scroll_conservatively
)
8983 max (dy
, CANON_Y_UNIT (f
) * max (scroll_step
, temp_scroll_step
));
8984 else if (scroll_step
|| temp_scroll_step
)
8985 amount_to_scroll
= scroll_max
;
8988 aggressive
= current_buffer
->scroll_up_aggressively
;
8989 height
= (WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
)
8990 - WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
8991 if (NUMBERP (aggressive
))
8992 amount_to_scroll
= XFLOATINT (aggressive
) * height
;
8995 if (amount_to_scroll
<= 0)
8998 move_it_vertically (&it
, - amount_to_scroll
);
8999 startp
= it
.current
.pos
;
9003 /* Run window scroll functions. */
9004 startp
= run_window_scroll_functions (window
, startp
);
9006 /* Display the window. Give up if new fonts are loaded, or if point
9008 if (!try_window (window
, startp
))
9010 else if (w
->cursor
.vpos
< 0)
9012 clear_glyph_matrix (w
->desired_matrix
);
9017 /* Maybe forget recorded base line for line number display. */
9018 if (!just_this_one_p
9019 || current_buffer
->clip_changed
9020 || BEG_UNCHANGED
< CHARPOS (startp
))
9021 w
->base_line_number
= Qnil
;
9023 /* If cursor ends up on a partially visible line, shift display
9024 lines up or down. */
9025 make_cursor_line_fully_visible (w
);
9033 /* Compute a suitable window start for window W if display of W starts
9034 on a continuation line. Value is non-zero if a new window start
9037 The new window start will be computed, based on W's width, starting
9038 from the start of the continued line. It is the start of the
9039 screen line with the minimum distance from the old start W->start. */
9042 compute_window_start_on_continuation_line (w
)
9045 struct text_pos pos
, start_pos
;
9046 int window_start_changed_p
= 0;
9048 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
9050 /* If window start is on a continuation line... Window start may be
9051 < BEGV in case there's invisible text at the start of the
9052 buffer (M-x rmail, for example). */
9053 if (CHARPOS (start_pos
) > BEGV
9054 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
9057 struct glyph_row
*row
;
9059 /* Handle the case that the window start is out of range. */
9060 if (CHARPOS (start_pos
) < BEGV
)
9061 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
9062 else if (CHARPOS (start_pos
) > ZV
)
9063 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
9065 /* Find the start of the continued line. This should be fast
9066 because scan_buffer is fast (newline cache). */
9067 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
9068 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
9069 row
, DEFAULT_FACE_ID
);
9070 reseat_at_previous_visible_line_start (&it
);
9072 /* If the line start is "too far" away from the window start,
9073 say it takes too much time to compute a new window start. */
9074 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
9075 < XFASTINT (w
->height
) * XFASTINT (w
->width
))
9077 int min_distance
, distance
;
9079 /* Move forward by display lines to find the new window
9080 start. If window width was enlarged, the new start can
9081 be expected to be > the old start. If window width was
9082 decreased, the new window start will be < the old start.
9083 So, we're looking for the display line start with the
9084 minimum distance from the old window start. */
9085 pos
= it
.current
.pos
;
9086 min_distance
= INFINITY
;
9087 while ((distance
= abs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
9088 distance
< min_distance
)
9090 min_distance
= distance
;
9091 pos
= it
.current
.pos
;
9092 move_it_by_lines (&it
, 1, 0);
9095 /* Set the window start there. */
9096 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
9097 window_start_changed_p
= 1;
9101 return window_start_changed_p
;
9105 /* Try cursor movement in case text has not changes in window WINDOW,
9106 with window start STARTP. Value is
9110 0 if this method cannot be used
9112 -1 if we know we have to scroll the display. *SCROLL_STEP is
9113 set to 1, under certain circumstances, if we want to scroll as
9114 if scroll-step were set to 1. See the code. */
9117 try_cursor_movement (window
, startp
, scroll_step
)
9119 struct text_pos startp
;
9122 struct window
*w
= XWINDOW (window
);
9123 struct frame
*f
= XFRAME (w
->frame
);
9126 /* Handle case where text has not changed, only point, and it has
9127 not moved off the frame. */
9128 if (/* Point may be in this window. */
9129 PT
>= CHARPOS (startp
)
9130 /* Selective display hasn't changed. */
9131 && !current_buffer
->clip_changed
9132 /* Function force-mode-line-update is used to force a thorough
9133 redisplay. It sets either windows_or_buffers_changed or
9134 update_mode_lines. So don't take a shortcut here for these
9136 && !update_mode_lines
9137 && !windows_or_buffers_changed
9138 /* Can't use this case if highlighting a region. When a
9139 region exists, cursor movement has to do more than just
9141 && !(!NILP (Vtransient_mark_mode
)
9142 && !NILP (current_buffer
->mark_active
))
9143 && NILP (w
->region_showing
)
9144 && NILP (Vshow_trailing_whitespace
)
9145 /* Right after splitting windows, last_point may be nil. */
9146 && INTEGERP (w
->last_point
)
9147 /* This code is not used for mini-buffer for the sake of the case
9148 of redisplaying to replace an echo area message; since in
9149 that case the mini-buffer contents per se are usually
9150 unchanged. This code is of no real use in the mini-buffer
9151 since the handling of this_line_start_pos, etc., in redisplay
9152 handles the same cases. */
9153 && !EQ (window
, minibuf_window
)
9154 /* When splitting windows or for new windows, it happens that
9155 redisplay is called with a nil window_end_vpos or one being
9156 larger than the window. This should really be fixed in
9157 window.c. I don't have this on my list, now, so we do
9158 approximately the same as the old redisplay code. --gerd. */
9159 && INTEGERP (w
->window_end_vpos
)
9160 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
9161 && (FRAME_WINDOW_P (f
)
9162 || !MARKERP (Voverlay_arrow_position
)
9163 || current_buffer
!= XMARKER (Voverlay_arrow_position
)->buffer
))
9165 int this_scroll_margin
;
9166 struct glyph_row
*row
;
9169 debug_method_add (w
, "cursor movement");
9172 /* Scroll if point within this distance from the top or bottom
9173 of the window. This is a pixel value. */
9174 this_scroll_margin
= max (0, scroll_margin
);
9175 this_scroll_margin
= min (this_scroll_margin
, XFASTINT (w
->height
) / 4);
9176 this_scroll_margin
*= CANON_Y_UNIT (f
);
9178 /* Start with the row the cursor was displayed during the last
9179 not paused redisplay. Give up if that row is not valid. */
9180 if (w
->last_cursor
.vpos
< 0
9181 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
9185 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
9186 if (row
->mode_line_p
)
9188 if (!row
->enabled_p
)
9195 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
9197 if (PT
> XFASTINT (w
->last_point
))
9199 /* Point has moved forward. */
9200 while (MATRIX_ROW_END_CHARPOS (row
) < PT
9201 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
9203 xassert (row
->enabled_p
);
9207 /* The end position of a row equals the start position
9208 of the next row. If PT is there, we would rather
9209 display it in the next line. */
9210 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
9211 && MATRIX_ROW_END_CHARPOS (row
) == PT
9212 && !cursor_row_p (w
, row
))
9215 /* If within the scroll margin, scroll. Note that
9216 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
9217 the next line would be drawn, and that
9218 this_scroll_margin can be zero. */
9219 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
9220 || PT
> MATRIX_ROW_END_CHARPOS (row
)
9221 /* Line is completely visible last line in window
9222 and PT is to be set in the next line. */
9223 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
9224 && PT
== MATRIX_ROW_END_CHARPOS (row
)
9225 && !row
->ends_at_zv_p
9226 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
9229 else if (PT
< XFASTINT (w
->last_point
))
9231 /* Cursor has to be moved backward. Note that PT >=
9232 CHARPOS (startp) because of the outer
9234 while (!row
->mode_line_p
9235 && (MATRIX_ROW_START_CHARPOS (row
) > PT
9236 || (MATRIX_ROW_START_CHARPOS (row
) == PT
9237 && MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)))
9238 && (row
->y
> this_scroll_margin
9239 || CHARPOS (startp
) == BEGV
))
9241 xassert (row
->enabled_p
);
9245 /* Consider the following case: Window starts at BEGV,
9246 there is invisible, intangible text at BEGV, so that
9247 display starts at some point START > BEGV. It can
9248 happen that we are called with PT somewhere between
9249 BEGV and START. Try to handle that case. */
9250 if (row
< w
->current_matrix
->rows
9251 || row
->mode_line_p
)
9253 row
= w
->current_matrix
->rows
;
9254 if (row
->mode_line_p
)
9258 /* Due to newlines in overlay strings, we may have to
9259 skip forward over overlay strings. */
9260 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
9261 && MATRIX_ROW_END_CHARPOS (row
) == PT
9262 && !cursor_row_p (w
, row
))
9265 /* If within the scroll margin, scroll. */
9266 if (row
->y
< this_scroll_margin
9267 && CHARPOS (startp
) != BEGV
)
9271 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
9272 || PT
> MATRIX_ROW_END_CHARPOS (row
))
9274 /* if PT is not in the glyph row, give up. */
9277 else if (MATRIX_ROW_PARTIALLY_VISIBLE_P (row
))
9279 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
9280 && !row
->ends_at_zv_p
9281 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
9283 else if (row
->height
> window_box_height (w
))
9285 /* If we end up in a partially visible line, let's
9286 make it fully visible, except when it's taller
9287 than the window, in which case we can't do much
9294 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
9295 try_window (window
, startp
);
9296 make_cursor_line_fully_visible (w
);
9304 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
9314 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
9315 selected_window is redisplayed. */
9318 redisplay_window (window
, just_this_one_p
)
9320 int just_this_one_p
;
9322 struct window
*w
= XWINDOW (window
);
9323 struct frame
*f
= XFRAME (w
->frame
);
9324 struct buffer
*buffer
= XBUFFER (w
->buffer
);
9325 struct buffer
*old
= current_buffer
;
9326 struct text_pos lpoint
, opoint
, startp
;
9327 int update_mode_line
;
9330 /* Record it now because it's overwritten. */
9331 int current_matrix_up_to_date_p
= 0;
9332 int temp_scroll_step
= 0;
9333 int count
= BINDING_STACK_SIZE ();
9336 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
9339 /* W must be a leaf window here. */
9340 xassert (!NILP (w
->buffer
));
9342 *w
->desired_matrix
->method
= 0;
9345 specbind (Qinhibit_point_motion_hooks
, Qt
);
9347 reconsider_clip_changes (w
, buffer
);
9349 /* Has the mode line to be updated? */
9350 update_mode_line
= (!NILP (w
->update_mode_line
)
9351 || update_mode_lines
9352 || buffer
->clip_changed
);
9354 if (MINI_WINDOW_P (w
))
9356 if (w
== XWINDOW (echo_area_window
)
9357 && !NILP (echo_area_buffer
[0]))
9359 if (update_mode_line
)
9360 /* We may have to update a tty frame's menu bar or a
9361 tool-bar. Example `M-x C-h C-h C-g'. */
9362 goto finish_menu_bars
;
9364 /* We've already displayed the echo area glyphs in this window. */
9365 goto finish_scroll_bars
;
9367 else if (w
!= XWINDOW (minibuf_window
))
9369 /* W is a mini-buffer window, but it's not the currently
9370 active one, so clear it. */
9371 int yb
= window_text_bottom_y (w
);
9372 struct glyph_row
*row
;
9375 for (y
= 0, row
= w
->desired_matrix
->rows
;
9377 y
+= row
->height
, ++row
)
9378 blank_row (w
, row
, y
);
9379 goto finish_scroll_bars
;
9383 /* Otherwise set up data on this window; select its buffer and point
9385 /* Really select the buffer, for the sake of buffer-local
9387 set_buffer_internal_1 (XBUFFER (w
->buffer
));
9388 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
9390 current_matrix_up_to_date_p
9391 = (!NILP (w
->window_end_valid
)
9392 && !current_buffer
->clip_changed
9393 && XFASTINT (w
->last_modified
) >= MODIFF
9394 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
9396 /* When windows_or_buffers_changed is non-zero, we can't rely on
9397 the window end being valid, so set it to nil there. */
9398 if (windows_or_buffers_changed
)
9400 /* If window starts on a continuation line, maybe adjust the
9401 window start in case the window's width changed. */
9402 if (XMARKER (w
->start
)->buffer
== current_buffer
)
9403 compute_window_start_on_continuation_line (w
);
9405 w
->window_end_valid
= Qnil
;
9408 /* Some sanity checks. */
9409 CHECK_WINDOW_END (w
);
9410 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
9412 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
9415 /* If %c is in mode line, update it if needed. */
9416 if (!NILP (w
->column_number_displayed
)
9417 /* This alternative quickly identifies a common case
9418 where no change is needed. */
9419 && !(PT
== XFASTINT (w
->last_point
)
9420 && XFASTINT (w
->last_modified
) >= MODIFF
9421 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
9422 && XFASTINT (w
->column_number_displayed
) != current_column ())
9423 update_mode_line
= 1;
9425 /* Count number of windows showing the selected buffer. An indirect
9426 buffer counts as its base buffer. */
9427 if (!just_this_one_p
)
9429 struct buffer
*current_base
, *window_base
;
9430 current_base
= current_buffer
;
9431 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
9432 if (current_base
->base_buffer
)
9433 current_base
= current_base
->base_buffer
;
9434 if (window_base
->base_buffer
)
9435 window_base
= window_base
->base_buffer
;
9436 if (current_base
== window_base
)
9440 /* Point refers normally to the selected window. For any other
9441 window, set up appropriate value. */
9442 if (!EQ (window
, selected_window
))
9444 int new_pt
= XMARKER (w
->pointm
)->charpos
;
9445 int new_pt_byte
= marker_byte_position (w
->pointm
);
9449 new_pt_byte
= BEGV_BYTE
;
9450 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
9452 else if (new_pt
> (ZV
- 1))
9455 new_pt_byte
= ZV_BYTE
;
9456 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
9459 /* We don't use SET_PT so that the point-motion hooks don't run. */
9460 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
9463 /* If any of the character widths specified in the display table
9464 have changed, invalidate the width run cache. It's true that
9465 this may be a bit late to catch such changes, but the rest of
9466 redisplay goes (non-fatally) haywire when the display table is
9467 changed, so why should we worry about doing any better? */
9468 if (current_buffer
->width_run_cache
)
9470 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
9472 if (! disptab_matches_widthtab (disptab
,
9473 XVECTOR (current_buffer
->width_table
)))
9475 invalidate_region_cache (current_buffer
,
9476 current_buffer
->width_run_cache
,
9478 recompute_width_table (current_buffer
, disptab
);
9482 /* If window-start is screwed up, choose a new one. */
9483 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
9486 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
9488 /* If someone specified a new starting point but did not insist,
9489 check whether it can be used. */
9490 if (!NILP (w
->optional_new_start
)
9491 && CHARPOS (startp
) >= BEGV
9492 && CHARPOS (startp
) <= ZV
)
9494 w
->optional_new_start
= Qnil
;
9495 start_display (&it
, w
, startp
);
9496 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
9497 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
9498 if (IT_CHARPOS (it
) == PT
)
9499 w
->force_start
= Qt
;
9502 /* Handle case where place to start displaying has been specified,
9503 unless the specified location is outside the accessible range. */
9504 if (!NILP (w
->force_start
)
9505 || w
->frozen_window_start_p
)
9507 w
->force_start
= Qnil
;
9509 w
->window_end_valid
= Qnil
;
9511 /* Forget any recorded base line for line number display. */
9512 if (!current_matrix_up_to_date_p
9513 || current_buffer
->clip_changed
)
9514 w
->base_line_number
= Qnil
;
9516 /* Redisplay the mode line. Select the buffer properly for that.
9517 Also, run the hook window-scroll-functions
9518 because we have scrolled. */
9519 /* Note, we do this after clearing force_start because
9520 if there's an error, it is better to forget about force_start
9521 than to get into an infinite loop calling the hook functions
9522 and having them get more errors. */
9523 if (!update_mode_line
9524 || ! NILP (Vwindow_scroll_functions
))
9526 update_mode_line
= 1;
9527 w
->update_mode_line
= Qt
;
9528 startp
= run_window_scroll_functions (window
, startp
);
9531 XSETFASTINT (w
->last_modified
, 0);
9532 XSETFASTINT (w
->last_overlay_modified
, 0);
9533 if (CHARPOS (startp
) < BEGV
)
9534 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
9535 else if (CHARPOS (startp
) > ZV
)
9536 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
9538 /* Redisplay, then check if cursor has been set during the
9539 redisplay. Give up if new fonts were loaded. */
9540 if (!try_window (window
, startp
))
9542 w
->force_start
= Qt
;
9543 clear_glyph_matrix (w
->desired_matrix
);
9544 goto finish_scroll_bars
;
9547 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
9549 /* If point does not appear, try to move point so it does
9550 appear. The desired matrix has been built above, so we
9553 struct glyph_row
*row
;
9555 window_height
= window_box_height (w
) / 2;
9556 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
9557 while (MATRIX_ROW_BOTTOM_Y (row
) < window_height
)
9560 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
9561 MATRIX_ROW_START_BYTEPOS (row
));
9563 if (w
!= XWINDOW (selected_window
))
9564 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
9565 else if (current_buffer
== old
)
9566 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
9568 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
9570 /* If we are highlighting the region, then we just changed
9571 the region, so redisplay to show it. */
9572 if (!NILP (Vtransient_mark_mode
)
9573 && !NILP (current_buffer
->mark_active
))
9575 clear_glyph_matrix (w
->desired_matrix
);
9576 if (!try_window (window
, startp
))
9577 goto finish_scroll_bars
;
9581 make_cursor_line_fully_visible (w
);
9583 debug_method_add (w
, "forced window start");
9588 /* Handle case where text has not changed, only point, and it has
9589 not moved off the frame. */
9590 if (current_matrix_up_to_date_p
9591 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
9599 /* If current starting point was originally the beginning of a line
9600 but no longer is, find a new starting point. */
9601 else if (!NILP (w
->start_at_line_beg
)
9602 && !(CHARPOS (startp
) <= BEGV
9603 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
9606 debug_method_add (w
, "recenter 1");
9611 /* Try scrolling with try_window_id. */
9612 else if (/* Windows and buffers haven't changed. */
9613 !windows_or_buffers_changed
9614 /* Window must be either use window-based redisplay or
9616 && (FRAME_WINDOW_P (f
)
9617 || (line_ins_del_ok
&& WINDOW_FULL_WIDTH_P (w
)))
9618 && !MINI_WINDOW_P (w
)
9619 /* Point is not known NOT to appear in window. */
9620 && PT
>= CHARPOS (startp
)
9621 && XFASTINT (w
->last_modified
)
9622 /* Window is not hscrolled. */
9623 && XFASTINT (w
->hscroll
) == 0
9624 /* Selective display has not changed. */
9625 && !current_buffer
->clip_changed
9626 /* Current matrix is up to date. */
9627 && !NILP (w
->window_end_valid
)
9628 /* Can't use this case if highlighting a region because
9629 a cursor movement will do more than just set the cursor. */
9630 && !(!NILP (Vtransient_mark_mode
)
9631 && !NILP (current_buffer
->mark_active
))
9632 && NILP (w
->region_showing
)
9633 && NILP (Vshow_trailing_whitespace
)
9634 /* Overlay arrow position and string not changed. */
9635 && EQ (last_arrow_position
, COERCE_MARKER (Voverlay_arrow_position
))
9636 && EQ (last_arrow_string
, Voverlay_arrow_string
)
9637 /* Value is > 0 if update has been done, it is -1 if we
9638 know that the same window start will not work. It is 0
9639 if unsuccessful for some other reason. */
9640 && (tem
= try_window_id (w
)) != 0)
9643 debug_method_add (w
, "try_window_id %d", tem
);
9646 if (fonts_changed_p
)
9647 goto finish_scroll_bars
;
9651 /* Otherwise try_window_id has returned -1 which means that we
9652 don't want the alternative below this comment to execute. */
9654 else if (CHARPOS (startp
) >= BEGV
9655 && CHARPOS (startp
) <= ZV
9656 && PT
>= CHARPOS (startp
)
9657 && (CHARPOS (startp
) < ZV
9658 /* Avoid starting at end of buffer. */
9659 || CHARPOS (startp
) == BEGV
9660 || (XFASTINT (w
->last_modified
) >= MODIFF
9661 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
9664 debug_method_add (w
, "same window start");
9667 /* Try to redisplay starting at same place as before.
9668 If point has not moved off frame, accept the results. */
9669 if (!current_matrix_up_to_date_p
9670 /* Don't use try_window_reusing_current_matrix in this case
9671 because a window scroll function can have changed the
9673 || !NILP (Vwindow_scroll_functions
)
9674 || MINI_WINDOW_P (w
)
9675 || !try_window_reusing_current_matrix (w
))
9677 IF_DEBUG (debug_method_add (w
, "1"));
9678 try_window (window
, startp
);
9681 if (fonts_changed_p
)
9682 goto finish_scroll_bars
;
9684 if (w
->cursor
.vpos
>= 0)
9686 if (!just_this_one_p
9687 || current_buffer
->clip_changed
9688 || BEG_UNCHANGED
< CHARPOS (startp
))
9689 /* Forget any recorded base line for line number display. */
9690 w
->base_line_number
= Qnil
;
9692 make_cursor_line_fully_visible (w
);
9696 clear_glyph_matrix (w
->desired_matrix
);
9701 XSETFASTINT (w
->last_modified
, 0);
9702 XSETFASTINT (w
->last_overlay_modified
, 0);
9704 /* Redisplay the mode line. Select the buffer properly for that. */
9705 if (!update_mode_line
)
9707 update_mode_line
= 1;
9708 w
->update_mode_line
= Qt
;
9711 /* Try to scroll by specified few lines. */
9712 if ((scroll_conservatively
9715 || NUMBERP (current_buffer
->scroll_up_aggressively
)
9716 || NUMBERP (current_buffer
->scroll_down_aggressively
))
9717 && !current_buffer
->clip_changed
9718 && CHARPOS (startp
) >= BEGV
9719 && CHARPOS (startp
) <= ZV
)
9721 /* The function returns -1 if new fonts were loaded, 1 if
9722 successful, 0 if not successful. */
9723 int rc
= try_scrolling (window
, just_this_one_p
,
9724 scroll_conservatively
,
9730 goto finish_scroll_bars
;
9733 /* Finally, just choose place to start which centers point */
9738 debug_method_add (w
, "recenter");
9741 /* w->vscroll = 0; */
9743 /* Forget any previously recorded base line for line number display. */
9744 if (!current_matrix_up_to_date_p
9745 || current_buffer
->clip_changed
)
9746 w
->base_line_number
= Qnil
;
9748 /* Move backward half the height of the window. */
9749 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
9750 it
.current_y
= it
.last_visible_y
;
9751 move_it_vertically_backward (&it
, it
.last_visible_y
/ 2);
9752 xassert (IT_CHARPOS (it
) >= BEGV
);
9754 /* The function move_it_vertically_backward may move over more
9755 than the specified y-distance. If it->w is small, e.g. a
9756 mini-buffer window, we may end up in front of the window's
9757 display area. Start displaying at the start of the line
9758 containing PT in this case. */
9759 if (it
.current_y
<= 0)
9761 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
9762 move_it_vertically (&it
, 0);
9763 xassert (IT_CHARPOS (it
) <= PT
);
9767 it
.current_x
= it
.hpos
= 0;
9769 /* Set startp here explicitly in case that helps avoid an infinite loop
9770 in case the window-scroll-functions functions get errors. */
9771 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
9773 /* Run scroll hooks. */
9774 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
9776 /* Redisplay the window. */
9777 if (!current_matrix_up_to_date_p
9778 || windows_or_buffers_changed
9779 /* Don't use try_window_reusing_current_matrix in this case
9780 because it can have changed the buffer. */
9781 || !NILP (Vwindow_scroll_functions
)
9783 || MINI_WINDOW_P (w
)
9784 || !try_window_reusing_current_matrix (w
))
9785 try_window (window
, startp
);
9787 /* If new fonts have been loaded (due to fontsets), give up. We
9788 have to start a new redisplay since we need to re-adjust glyph
9790 if (fonts_changed_p
)
9791 goto finish_scroll_bars
;
9793 /* If cursor did not appear assume that the middle of the window is
9794 in the first line of the window. Do it again with the next line.
9795 (Imagine a window of height 100, displaying two lines of height
9796 60. Moving back 50 from it->last_visible_y will end in the first
9798 if (w
->cursor
.vpos
< 0)
9800 if (!NILP (w
->window_end_valid
)
9801 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
9803 clear_glyph_matrix (w
->desired_matrix
);
9804 move_it_by_lines (&it
, 1, 0);
9805 try_window (window
, it
.current
.pos
);
9807 else if (PT
< IT_CHARPOS (it
))
9809 clear_glyph_matrix (w
->desired_matrix
);
9810 move_it_by_lines (&it
, -1, 0);
9811 try_window (window
, it
.current
.pos
);
9815 /* Not much we can do about it. */
9819 /* Consider the following case: Window starts at BEGV, there is
9820 invisible, intangible text at BEGV, so that display starts at
9821 some point START > BEGV. It can happen that we are called with
9822 PT somewhere between BEGV and START. Try to handle that case. */
9823 if (w
->cursor
.vpos
< 0)
9825 struct glyph_row
*row
= w
->current_matrix
->rows
;
9826 if (row
->mode_line_p
)
9828 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
9831 make_cursor_line_fully_visible (w
);
9835 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
9836 w
->start_at_line_beg
= ((CHARPOS (startp
) == BEGV
9837 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n')
9840 /* Display the mode line, if we must. */
9841 if ((update_mode_line
9842 /* If window not full width, must redo its mode line
9843 if (a) the window to its side is being redone and
9844 (b) we do a frame-based redisplay. This is a consequence
9845 of how inverted lines are drawn in frame-based redisplay. */
9846 || (!just_this_one_p
9847 && !FRAME_WINDOW_P (f
)
9848 && !WINDOW_FULL_WIDTH_P (w
))
9849 /* Line number to display. */
9850 || INTEGERP (w
->base_line_pos
)
9851 /* Column number is displayed and different from the one displayed. */
9852 || (!NILP (w
->column_number_displayed
)
9853 && XFASTINT (w
->column_number_displayed
) != current_column ()))
9854 /* This means that the window has a mode line. */
9855 && (WINDOW_WANTS_MODELINE_P (w
)
9856 || WINDOW_WANTS_HEADER_LINE_P (w
)))
9858 Lisp_Object old_selected_frame
;
9860 old_selected_frame
= selected_frame
;
9862 XSETFRAME (selected_frame
, f
);
9863 display_mode_lines (w
);
9864 selected_frame
= old_selected_frame
;
9866 /* If mode line height has changed, arrange for a thorough
9867 immediate redisplay using the correct mode line height. */
9868 if (WINDOW_WANTS_MODELINE_P (w
)
9869 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
9871 fonts_changed_p
= 1;
9872 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
9873 = DESIRED_MODE_LINE_HEIGHT (w
);
9876 /* If top line height has changed, arrange for a thorough
9877 immediate redisplay using the correct mode line height. */
9878 if (WINDOW_WANTS_HEADER_LINE_P (w
)
9879 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
9881 fonts_changed_p
= 1;
9882 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
9883 = DESIRED_HEADER_LINE_HEIGHT (w
);
9886 if (fonts_changed_p
)
9887 goto finish_scroll_bars
;
9890 if (!line_number_displayed
9891 && !BUFFERP (w
->base_line_pos
))
9893 w
->base_line_pos
= Qnil
;
9894 w
->base_line_number
= Qnil
;
9899 /* When we reach a frame's selected window, redo the frame's menu bar. */
9900 if (update_mode_line
9901 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
9903 int redisplay_menu_p
= 0;
9905 if (FRAME_WINDOW_P (f
))
9907 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
9908 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
9910 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
9914 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
9916 if (redisplay_menu_p
)
9917 display_menu_bar (w
);
9919 #ifdef HAVE_WINDOW_SYSTEM
9920 if (WINDOWP (f
->tool_bar_window
)
9921 && (FRAME_TOOL_BAR_LINES (f
) > 0
9922 || auto_resize_tool_bars_p
))
9923 redisplay_tool_bar (f
);
9929 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9931 int start
, end
, whole
;
9933 /* Calculate the start and end positions for the current window.
9934 At some point, it would be nice to choose between scrollbars
9935 which reflect the whole buffer size, with special markers
9936 indicating narrowing, and scrollbars which reflect only the
9939 Note that mini-buffers sometimes aren't displaying any text. */
9940 if (!MINI_WINDOW_P (w
)
9941 || (w
== XWINDOW (minibuf_window
)
9942 && NILP (echo_area_buffer
[0])))
9945 start
= marker_position (w
->start
) - BEGV
;
9946 /* I don't think this is guaranteed to be right. For the
9947 moment, we'll pretend it is. */
9948 end
= (Z
- XFASTINT (w
->window_end_pos
)) - BEGV
;
9952 if (whole
< (end
- start
))
9953 whole
= end
- start
;
9956 start
= end
= whole
= 0;
9958 /* Indicate what this scroll bar ought to be displaying now. */
9959 set_vertical_scroll_bar_hook (w
, end
- start
, whole
, start
);
9961 /* Note that we actually used the scroll bar attached to this
9962 window, so it shouldn't be deleted at the end of redisplay. */
9963 redeem_scroll_bar_hook (w
);
9966 /* Restore current_buffer and value of point in it. */
9967 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
9968 set_buffer_internal_1 (old
);
9969 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
9971 unbind_to (count
, Qnil
);
9975 /* Build the complete desired matrix of WINDOW with a window start
9976 buffer position POS. Value is non-zero if successful. It is zero
9977 if fonts were loaded during redisplay which makes re-adjusting
9978 glyph matrices necessary. */
9981 try_window (window
, pos
)
9983 struct text_pos pos
;
9985 struct window
*w
= XWINDOW (window
);
9987 struct glyph_row
*last_text_row
= NULL
;
9989 /* Make POS the new window start. */
9990 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
9992 /* Mark cursor position as unknown. No overlay arrow seen. */
9993 w
->cursor
.vpos
= -1;
9994 overlay_arrow_seen
= 0;
9996 /* Initialize iterator and info to start at POS. */
9997 start_display (&it
, w
, pos
);
9999 /* Display all lines of W. */
10000 while (it
.current_y
< it
.last_visible_y
)
10002 if (display_line (&it
))
10003 last_text_row
= it
.glyph_row
- 1;
10004 if (fonts_changed_p
)
10008 /* If bottom moved off end of frame, change mode line percentage. */
10009 if (XFASTINT (w
->window_end_pos
) <= 0
10010 && Z
!= IT_CHARPOS (it
))
10011 w
->update_mode_line
= Qt
;
10013 /* Set window_end_pos to the offset of the last character displayed
10014 on the window from the end of current_buffer. Set
10015 window_end_vpos to its row number. */
10018 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
10019 w
->window_end_bytepos
10020 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
10021 XSETFASTINT (w
->window_end_pos
,
10022 Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
10023 XSETFASTINT (w
->window_end_vpos
,
10024 MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
10025 xassert (MATRIX_ROW (w
->desired_matrix
, XFASTINT (w
->window_end_vpos
))
10026 ->displays_text_p
);
10030 w
->window_end_bytepos
= 0;
10031 XSETFASTINT (w
->window_end_pos
, 0);
10032 XSETFASTINT (w
->window_end_vpos
, 0);
10035 /* But that is not valid info until redisplay finishes. */
10036 w
->window_end_valid
= Qnil
;
10042 /************************************************************************
10043 Window redisplay reusing current matrix when buffer has not changed
10044 ************************************************************************/
10046 /* Try redisplay of window W showing an unchanged buffer with a
10047 different window start than the last time it was displayed by
10048 reusing its current matrix. Value is non-zero if successful.
10049 W->start is the new window start. */
10052 try_window_reusing_current_matrix (w
)
10055 struct frame
*f
= XFRAME (w
->frame
);
10056 struct glyph_row
*row
, *bottom_row
;
10059 struct text_pos start
, new_start
;
10060 int nrows_scrolled
, i
;
10061 struct glyph_row
*last_text_row
;
10062 struct glyph_row
*last_reused_text_row
;
10063 struct glyph_row
*start_row
;
10064 int start_vpos
, min_y
, max_y
;
10066 if (/* This function doesn't handle terminal frames. */
10067 !FRAME_WINDOW_P (f
)
10068 /* Don't try to reuse the display if windows have been split
10070 || windows_or_buffers_changed
)
10073 /* Can't do this if region may have changed. */
10074 if ((!NILP (Vtransient_mark_mode
)
10075 && !NILP (current_buffer
->mark_active
))
10076 || !NILP (w
->region_showing
)
10077 || !NILP (Vshow_trailing_whitespace
))
10080 /* If top-line visibility has changed, give up. */
10081 if (WINDOW_WANTS_HEADER_LINE_P (w
)
10082 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
10085 /* Give up if old or new display is scrolled vertically. We could
10086 make this function handle this, but right now it doesn't. */
10087 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10088 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (start_row
))
10091 /* The variable new_start now holds the new window start. The old
10092 start `start' can be determined from the current matrix. */
10093 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
10094 start
= start_row
->start
.pos
;
10095 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
10097 /* Clear the desired matrix for the display below. */
10098 clear_glyph_matrix (w
->desired_matrix
);
10100 if (CHARPOS (new_start
) <= CHARPOS (start
))
10104 IF_DEBUG (debug_method_add (w
, "twu1"));
10106 /* Display up to a row that can be reused. The variable
10107 last_text_row is set to the last row displayed that displays
10108 text. Note that it.vpos == 0 if or if not there is a
10109 header-line; it's not the same as the MATRIX_ROW_VPOS! */
10110 start_display (&it
, w
, new_start
);
10111 first_row_y
= it
.current_y
;
10112 w
->cursor
.vpos
= -1;
10113 last_text_row
= last_reused_text_row
= NULL
;
10115 while (it
.current_y
< it
.last_visible_y
10116 && IT_CHARPOS (it
) < CHARPOS (start
)
10117 && !fonts_changed_p
)
10118 if (display_line (&it
))
10119 last_text_row
= it
.glyph_row
- 1;
10121 /* A value of current_y < last_visible_y means that we stopped
10122 at the previous window start, which in turn means that we
10123 have at least one reusable row. */
10124 if (it
.current_y
< it
.last_visible_y
)
10126 /* IT.vpos always starts from 0; it counts text lines. */
10127 nrows_scrolled
= it
.vpos
;
10129 /* Find PT if not already found in the lines displayed. */
10130 if (w
->cursor
.vpos
< 0)
10132 int dy
= it
.current_y
- first_row_y
;
10134 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10135 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10137 if (PT
>= MATRIX_ROW_START_CHARPOS (row
)
10138 && PT
< MATRIX_ROW_END_CHARPOS (row
))
10140 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
10141 dy
, nrows_scrolled
);
10145 if (MATRIX_ROW_BOTTOM_Y (row
) + dy
>= it
.last_visible_y
)
10151 /* Give up if point was not found. This shouldn't
10152 happen often; not more often than with try_window
10154 if (w
->cursor
.vpos
< 0)
10156 clear_glyph_matrix (w
->desired_matrix
);
10161 /* Scroll the display. Do it before the current matrix is
10162 changed. The problem here is that update has not yet
10163 run, i.e. part of the current matrix is not up to date.
10164 scroll_run_hook will clear the cursor, and use the
10165 current matrix to get the height of the row the cursor is
10167 run
.current_y
= first_row_y
;
10168 run
.desired_y
= it
.current_y
;
10169 run
.height
= it
.last_visible_y
- it
.current_y
;
10171 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
10174 rif
->update_window_begin_hook (w
);
10175 rif
->clear_mouse_face (w
);
10176 rif
->scroll_run_hook (w
, &run
);
10177 rif
->update_window_end_hook (w
, 0, 0);
10181 /* Shift current matrix down by nrows_scrolled lines. */
10182 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
10183 rotate_matrix (w
->current_matrix
,
10185 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
10188 /* Disable lines not reused. */
10189 for (i
= 0; i
< it
.vpos
; ++i
)
10190 (start_row
+ i
)->enabled_p
= 0;
10192 /* Re-compute Y positions. */
10193 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10194 max_y
= it
.last_visible_y
;
10195 for (row
= start_row
+ nrows_scrolled
;
10199 row
->y
= it
.current_y
;
10201 if (row
->y
< min_y
)
10202 row
->visible_height
= row
->height
- (min_y
- row
->y
);
10203 else if (row
->y
+ row
->height
> max_y
)
10204 row
->visible_height
10205 = row
->height
- (row
->y
+ row
->height
- max_y
);
10207 row
->visible_height
= row
->height
;
10209 it
.current_y
+= row
->height
;
10211 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10212 last_reused_text_row
= row
;
10213 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
10218 /* Update window_end_pos etc.; last_reused_text_row is the last
10219 reused row from the current matrix containing text, if any.
10220 The value of last_text_row is the last displayed line
10221 containing text. */
10222 if (last_reused_text_row
)
10224 w
->window_end_bytepos
10225 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
10226 XSETFASTINT (w
->window_end_pos
,
10227 Z
- MATRIX_ROW_END_CHARPOS (last_reused_text_row
));
10228 XSETFASTINT (w
->window_end_vpos
,
10229 MATRIX_ROW_VPOS (last_reused_text_row
,
10230 w
->current_matrix
));
10232 else if (last_text_row
)
10234 w
->window_end_bytepos
10235 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
10236 XSETFASTINT (w
->window_end_pos
,
10237 Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
10238 XSETFASTINT (w
->window_end_vpos
,
10239 MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
10243 /* This window must be completely empty. */
10244 w
->window_end_bytepos
= 0;
10245 XSETFASTINT (w
->window_end_pos
, 0);
10246 XSETFASTINT (w
->window_end_vpos
, 0);
10248 w
->window_end_valid
= Qnil
;
10250 /* Update hint: don't try scrolling again in update_window. */
10251 w
->desired_matrix
->no_scrolling_p
= 1;
10254 debug_method_add (w
, "try_window_reusing_current_matrix 1");
10258 else if (CHARPOS (new_start
) > CHARPOS (start
))
10260 struct glyph_row
*pt_row
, *row
;
10261 struct glyph_row
*first_reusable_row
;
10262 struct glyph_row
*first_row_to_display
;
10264 int yb
= window_text_bottom_y (w
);
10266 IF_DEBUG (debug_method_add (w
, "twu2"));
10268 /* Find the row starting at new_start, if there is one. Don't
10269 reuse a partially visible line at the end. */
10270 first_reusable_row
= start_row
;
10271 while (first_reusable_row
->enabled_p
10272 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
10273 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
10274 < CHARPOS (new_start
)))
10275 ++first_reusable_row
;
10277 /* Give up if there is no row to reuse. */
10278 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
10279 || !first_reusable_row
->enabled_p
10280 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
10281 != CHARPOS (new_start
)))
10284 /* We can reuse fully visible rows beginning with
10285 first_reusable_row to the end of the window. Set
10286 first_row_to_display to the first row that cannot be reused.
10287 Set pt_row to the row containing point, if there is any. */
10288 first_row_to_display
= first_reusable_row
;
10290 while (MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
)
10292 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
10293 && PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
))
10294 pt_row
= first_row_to_display
;
10296 ++first_row_to_display
;
10299 /* Start displaying at the start of first_row_to_display. */
10300 xassert (first_row_to_display
->y
< yb
);
10301 init_to_row_start (&it
, w
, first_row_to_display
);
10302 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
10304 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
10306 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
10307 + WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
));
10309 /* Display lines beginning with first_row_to_display in the
10310 desired matrix. Set last_text_row to the last row displayed
10311 that displays text. */
10312 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
10313 if (pt_row
== NULL
)
10314 w
->cursor
.vpos
= -1;
10315 last_text_row
= NULL
;
10316 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
10317 if (display_line (&it
))
10318 last_text_row
= it
.glyph_row
- 1;
10320 /* Give up If point isn't in a row displayed or reused. */
10321 if (w
->cursor
.vpos
< 0)
10323 clear_glyph_matrix (w
->desired_matrix
);
10327 /* If point is in a reused row, adjust y and vpos of the cursor
10331 w
->cursor
.vpos
-= MATRIX_ROW_VPOS (first_reusable_row
,
10332 w
->current_matrix
);
10333 w
->cursor
.y
-= first_reusable_row
->y
;
10336 /* Scroll the display. */
10337 run
.current_y
= first_reusable_row
->y
;
10338 run
.desired_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10339 run
.height
= it
.last_visible_y
- run
.current_y
;
10340 dy
= run
.current_y
- run
.desired_y
;
10344 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
10346 rif
->update_window_begin_hook (w
);
10347 rif
->clear_mouse_face (w
);
10348 rif
->scroll_run_hook (w
, &run
);
10349 rif
->update_window_end_hook (w
, 0, 0);
10353 /* Adjust Y positions of reused rows. */
10354 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
10355 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
10356 max_y
= it
.last_visible_y
;
10357 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
10360 if (row
->y
< min_y
)
10361 row
->visible_height
= row
->height
- (min_y
- row
->y
);
10362 else if (row
->y
+ row
->height
> max_y
)
10363 row
->visible_height
10364 = row
->height
- (row
->y
+ row
->height
- max_y
);
10366 row
->visible_height
= row
->height
;
10369 /* Disable rows not reused. */
10370 while (row
< bottom_row
)
10372 row
->enabled_p
= 0;
10376 /* Scroll the current matrix. */
10377 xassert (nrows_scrolled
> 0);
10378 rotate_matrix (w
->current_matrix
,
10380 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
10383 /* Adjust window end. A null value of last_text_row means that
10384 the window end is in reused rows which in turn means that
10385 only its vpos can have changed. */
10388 w
->window_end_bytepos
10389 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
10390 XSETFASTINT (w
->window_end_pos
,
10391 Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
10392 XSETFASTINT (w
->window_end_vpos
,
10393 MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
10397 XSETFASTINT (w
->window_end_vpos
,
10398 XFASTINT (w
->window_end_vpos
) - nrows_scrolled
);
10401 w
->window_end_valid
= Qnil
;
10402 w
->desired_matrix
->no_scrolling_p
= 1;
10405 debug_method_add (w
, "try_window_reusing_current_matrix 2");
10415 /************************************************************************
10416 Window redisplay reusing current matrix when buffer has changed
10417 ************************************************************************/
10419 static struct glyph_row
*find_last_unchanged_at_beg_row
P_ ((struct window
*));
10420 static struct glyph_row
*find_first_unchanged_at_end_row
P_ ((struct window
*,
10422 static struct glyph_row
*
10423 find_last_row_displaying_text
P_ ((struct glyph_matrix
*, struct it
*,
10424 struct glyph_row
*));
10427 /* Return the last row in MATRIX displaying text. If row START is
10428 non-null, start searching with that row. IT gives the dimensions
10429 of the display. Value is null if matrix is empty; otherwise it is
10430 a pointer to the row found. */
10432 static struct glyph_row
*
10433 find_last_row_displaying_text (matrix
, it
, start
)
10434 struct glyph_matrix
*matrix
;
10436 struct glyph_row
*start
;
10438 struct glyph_row
*row
, *row_found
;
10440 /* Set row_found to the last row in IT->w's current matrix
10441 displaying text. The loop looks funny but think of partially
10444 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
10445 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10447 xassert (row
->enabled_p
);
10449 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
10458 /* Return the last row in the current matrix of W that is not affected
10459 by changes at the start of current_buffer that occurred since the
10460 last time W was redisplayed. Value is null if no such row exists.
10462 The global variable beg_unchanged has to contain the number of
10463 bytes unchanged at the start of current_buffer. BEG +
10464 beg_unchanged is the buffer position of the first changed byte in
10465 current_buffer. Characters at positions < BEG + beg_unchanged are
10466 at the same buffer positions as they were when the current matrix
10469 static struct glyph_row
*
10470 find_last_unchanged_at_beg_row (w
)
10473 int first_changed_pos
= BEG
+ BEG_UNCHANGED
;
10474 struct glyph_row
*row
;
10475 struct glyph_row
*row_found
= NULL
;
10476 int yb
= window_text_bottom_y (w
);
10478 /* Find the last row displaying unchanged text. */
10479 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10480 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
10481 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
)
10483 if (/* If row ends before first_changed_pos, it is unchanged,
10484 except in some case. */
10485 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
10486 /* When row ends in ZV and we write at ZV it is not
10488 && !row
->ends_at_zv_p
10489 /* When first_changed_pos is the end of a continued line,
10490 row is not unchanged because it may be no longer
10492 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
10493 && row
->continued_p
))
10496 /* Stop if last visible row. */
10497 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
10507 /* Find the first glyph row in the current matrix of W that is not
10508 affected by changes at the end of current_buffer since the last
10509 time the window was redisplayed. Return in *DELTA the number of
10510 chars by which buffer positions in unchanged text at the end of
10511 current_buffer must be adjusted. Return in *DELTA_BYTES the
10512 corresponding number of bytes. Value is null if no such row
10513 exists, i.e. all rows are affected by changes. */
10515 static struct glyph_row
*
10516 find_first_unchanged_at_end_row (w
, delta
, delta_bytes
)
10518 int *delta
, *delta_bytes
;
10520 struct glyph_row
*row
;
10521 struct glyph_row
*row_found
= NULL
;
10523 *delta
= *delta_bytes
= 0;
10525 /* Display must not have been paused, otherwise the current matrix
10526 is not up to date. */
10527 if (NILP (w
->window_end_valid
))
10530 /* A value of window_end_pos >= END_UNCHANGED means that the window
10531 end is in the range of changed text. If so, there is no
10532 unchanged row at the end of W's current matrix. */
10533 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
10536 /* Set row to the last row in W's current matrix displaying text. */
10537 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
10539 /* If matrix is entirely empty, no unchanged row exists. */
10540 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10542 /* The value of row is the last glyph row in the matrix having a
10543 meaningful buffer position in it. The end position of row
10544 corresponds to window_end_pos. This allows us to translate
10545 buffer positions in the current matrix to current buffer
10546 positions for characters not in changed text. */
10547 int Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
10548 int Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
10549 int last_unchanged_pos
, last_unchanged_pos_old
;
10550 struct glyph_row
*first_text_row
10551 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10553 *delta
= Z
- Z_old
;
10554 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
10556 /* Set last_unchanged_pos to the buffer position of the last
10557 character in the buffer that has not been changed. Z is the
10558 index + 1 of the last byte in current_buffer, i.e. by
10559 subtracting end_unchanged we get the index of the last
10560 unchanged character, and we have to add BEG to get its buffer
10562 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
10563 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
10565 /* Search backward from ROW for a row displaying a line that
10566 starts at a minimum position >= last_unchanged_pos_old. */
10567 for (; row
> first_text_row
; --row
)
10569 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
10572 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
10577 if (row_found
&& !MATRIX_ROW_DISPLAYS_TEXT_P (row_found
))
10584 /* Make sure that glyph rows in the current matrix of window W
10585 reference the same glyph memory as corresponding rows in the
10586 frame's frame matrix. This function is called after scrolling W's
10587 current matrix on a terminal frame in try_window_id and
10588 try_window_reusing_current_matrix. */
10591 sync_frame_with_window_matrix_rows (w
)
10594 struct frame
*f
= XFRAME (w
->frame
);
10595 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
10597 /* Preconditions: W must be a leaf window and full-width. Its frame
10598 must have a frame matrix. */
10599 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
10600 xassert (WINDOW_FULL_WIDTH_P (w
));
10601 xassert (!FRAME_WINDOW_P (f
));
10603 /* If W is a full-width window, glyph pointers in W's current matrix
10604 have, by definition, to be the same as glyph pointers in the
10605 corresponding frame matrix. */
10606 window_row
= w
->current_matrix
->rows
;
10607 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
10608 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
10609 while (window_row
< window_row_end
)
10613 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
10614 frame_row
->glyphs
[area
] = window_row
->glyphs
[area
];
10616 /* Disable frame rows whose corresponding window rows have
10617 been disabled in try_window_id. */
10618 if (!window_row
->enabled_p
)
10619 frame_row
->enabled_p
= 0;
10621 ++window_row
, ++frame_row
;
10626 /* Find the glyph row in window W containing CHARPOS. Consider all
10627 rows between START and END (not inclusive). END null means search
10628 all rows to the end of the display area of W. Value is the row
10629 containing CHARPOS or null. */
10631 static struct glyph_row
*
10632 row_containing_pos (w
, charpos
, start
, end
)
10635 struct glyph_row
*start
, *end
;
10637 struct glyph_row
*row
= start
;
10640 /* If we happen to start on a header-line, skip that. */
10641 if (row
->mode_line_p
)
10644 if ((end
&& row
>= end
) || !row
->enabled_p
)
10647 last_y
= window_text_bottom_y (w
);
10649 while ((end
== NULL
|| row
< end
)
10650 && (MATRIX_ROW_END_CHARPOS (row
) < charpos
10651 /* The end position of a row equals the start
10652 position of the next row. If CHARPOS is there, we
10653 would rather display it in the next line, except
10654 when this line ends in ZV. */
10655 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
10656 && (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)
10657 || !row
->ends_at_zv_p
)))
10658 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
10661 /* Give up if CHARPOS not found. */
10662 if ((end
&& row
>= end
)
10663 || charpos
< MATRIX_ROW_START_CHARPOS (row
)
10664 || charpos
> MATRIX_ROW_END_CHARPOS (row
))
10671 /* Try to redisplay window W by reusing its existing display. W's
10672 current matrix must be up to date when this function is called,
10673 i.e. window_end_valid must not be nil.
10677 1 if display has been updated
10678 0 if otherwise unsuccessful
10679 -1 if redisplay with same window start is known not to succeed
10681 The following steps are performed:
10683 1. Find the last row in the current matrix of W that is not
10684 affected by changes at the start of current_buffer. If no such row
10687 2. Find the first row in W's current matrix that is not affected by
10688 changes at the end of current_buffer. Maybe there is no such row.
10690 3. Display lines beginning with the row + 1 found in step 1 to the
10691 row found in step 2 or, if step 2 didn't find a row, to the end of
10694 4. If cursor is not known to appear on the window, give up.
10696 5. If display stopped at the row found in step 2, scroll the
10697 display and current matrix as needed.
10699 6. Maybe display some lines at the end of W, if we must. This can
10700 happen under various circumstances, like a partially visible line
10701 becoming fully visible, or because newly displayed lines are displayed
10702 in smaller font sizes.
10704 7. Update W's window end information. */
10706 /* Check that window end is what we expect it to be. */
10712 struct frame
*f
= XFRAME (w
->frame
);
10713 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
10714 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
10715 struct glyph_row
*last_unchanged_at_beg_row
;
10716 struct glyph_row
*first_unchanged_at_end_row
;
10717 struct glyph_row
*row
;
10718 struct glyph_row
*bottom_row
;
10721 int delta
= 0, delta_bytes
= 0, stop_pos
, dvpos
, dy
;
10722 struct text_pos start_pos
;
10724 int first_unchanged_at_end_vpos
= 0;
10725 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
10726 struct text_pos start
;
10728 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
10730 /* Check pre-conditions. Window end must be valid, otherwise
10731 the current matrix would not be up to date. */
10732 xassert (!NILP (w
->window_end_valid
));
10733 xassert (FRAME_WINDOW_P (XFRAME (w
->frame
))
10734 || (line_ins_del_ok
&& WINDOW_FULL_WIDTH_P (w
)));
10736 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
10737 only if buffer has really changed. The reason is that the gap is
10738 initially at Z for freshly visited files. The code below would
10739 set end_unchanged to 0 in that case. */
10740 if (MODIFF
> SAVE_MODIFF
10741 /* This seems to happen sometimes after saving a buffer. */
10742 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
10744 if (GPT
- BEG
< BEG_UNCHANGED
)
10745 BEG_UNCHANGED
= GPT
- BEG
;
10746 if (Z
- GPT
< END_UNCHANGED
)
10747 END_UNCHANGED
= Z
- GPT
;
10750 /* If window starts after a line end, and the last change is in
10751 front of that newline, then changes don't affect the display.
10752 This case happens with stealth-fontification. Note that although
10753 the display is unchanged, glyph positions in the matrix have to
10754 be adjusted, of course. */
10755 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
10756 if (CHARPOS (start
) > BEGV
10757 && Z
- END_UNCHANGED
< CHARPOS (start
) - 1
10758 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n'
10759 && PT
< MATRIX_ROW_END_CHARPOS (row
))
10761 struct glyph_row
*r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
10762 int delta
= CHARPOS (start
) - MATRIX_ROW_START_CHARPOS (r0
);
10766 struct glyph_row
*r1
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
10767 int delta_bytes
= BYTEPOS (start
) - MATRIX_ROW_START_BYTEPOS (r0
);
10769 increment_matrix_positions (w
->current_matrix
,
10770 MATRIX_ROW_VPOS (r0
, current_matrix
),
10771 MATRIX_ROW_VPOS (r1
, current_matrix
),
10772 delta
, delta_bytes
);
10775 #if 0 /* If changes are all in front of the window start, the
10776 distance of the last displayed glyph from Z hasn't
10779 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
10780 w
->window_end_bytepos
10781 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
10784 row
= row_containing_pos (w
, PT
, r0
, NULL
);
10788 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10792 /* Return quickly if changes are all below what is displayed in the
10793 window, and if PT is in the window. */
10794 if (BEG_UNCHANGED
> MATRIX_ROW_END_CHARPOS (row
)
10795 && PT
< MATRIX_ROW_END_CHARPOS (row
))
10797 /* We have to update window end positions because the buffer's
10798 size has changed. */
10800 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
10801 w
->window_end_bytepos
10802 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
10804 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10805 row
= row_containing_pos (w
, PT
, row
, NULL
);
10806 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10810 /* Check that window start agrees with the start of the first glyph
10811 row in its current matrix. Check this after we know the window
10812 start is not in changed text, otherwise positions would not be
10814 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
10815 if (!TEXT_POS_EQUAL_P (start
, row
->start
.pos
))
10818 /* Compute the position at which we have to start displaying new
10819 lines. Some of the lines at the top of the window might be
10820 reusable because they are not displaying changed text. Find the
10821 last row in W's current matrix not affected by changes at the
10822 start of current_buffer. Value is null if changes start in the
10823 first line of window. */
10824 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
10825 if (last_unchanged_at_beg_row
)
10827 /* Avoid starting to display in the moddle of a character, a TAB
10828 for instance. This is easier than to set up the iterator
10829 exactly, and it's not a frequent case, so the additional
10830 effort wouldn't really pay off. */
10831 while (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
10832 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
10833 --last_unchanged_at_beg_row
;
10835 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
10838 init_to_row_end (&it
, w
, last_unchanged_at_beg_row
);
10839 start_pos
= it
.current
.pos
;
10841 /* Start displaying new lines in the desired matrix at the same
10842 vpos we would use in the current matrix, i.e. below
10843 last_unchanged_at_beg_row. */
10844 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
10846 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
10847 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
10849 xassert (it
.hpos
== 0 && it
.current_x
== 0);
10853 /* There are no reusable lines at the start of the window.
10854 Start displaying in the first line. */
10855 start_display (&it
, w
, start
);
10856 start_pos
= it
.current
.pos
;
10859 /* Find the first row that is not affected by changes at the end of
10860 the buffer. Value will be null if there is no unchanged row, in
10861 which case we must redisplay to the end of the window. delta
10862 will be set to the value by which buffer positions beginning with
10863 first_unchanged_at_end_row have to be adjusted due to text
10865 first_unchanged_at_end_row
10866 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
10867 IF_DEBUG (debug_delta
= delta
);
10868 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
10870 /* Set stop_pos to the buffer position up to which we will have to
10871 display new lines. If first_unchanged_at_end_row != NULL, this
10872 is the buffer position of the start of the line displayed in that
10873 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
10874 that we don't stop at a buffer position. */
10876 if (first_unchanged_at_end_row
)
10878 xassert (last_unchanged_at_beg_row
== NULL
10879 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
10881 /* If this is a continuation line, move forward to the next one
10882 that isn't. Changes in lines above affect this line.
10883 Caution: this may move first_unchanged_at_end_row to a row
10884 not displaying text. */
10885 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
10886 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
10887 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
10888 < it
.last_visible_y
))
10889 ++first_unchanged_at_end_row
;
10891 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
10892 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
10893 >= it
.last_visible_y
))
10894 first_unchanged_at_end_row
= NULL
;
10897 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
10899 first_unchanged_at_end_vpos
10900 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
10901 xassert (stop_pos
>= Z
- END_UNCHANGED
);
10904 else if (last_unchanged_at_beg_row
== NULL
)
10910 /* Either there is no unchanged row at the end, or the one we have
10911 now displays text. This is a necessary condition for the window
10912 end pos calculation at the end of this function. */
10913 xassert (first_unchanged_at_end_row
== NULL
10914 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
10916 debug_last_unchanged_at_beg_vpos
10917 = (last_unchanged_at_beg_row
10918 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
10920 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
10922 #endif /* GLYPH_DEBUG != 0 */
10925 /* Display new lines. Set last_text_row to the last new line
10926 displayed which has text on it, i.e. might end up as being the
10927 line where the window_end_vpos is. */
10928 w
->cursor
.vpos
= -1;
10929 last_text_row
= NULL
;
10930 overlay_arrow_seen
= 0;
10931 while (it
.current_y
< it
.last_visible_y
10932 && !fonts_changed_p
10933 && (first_unchanged_at_end_row
== NULL
10934 || IT_CHARPOS (it
) < stop_pos
))
10936 if (display_line (&it
))
10937 last_text_row
= it
.glyph_row
- 1;
10940 if (fonts_changed_p
)
10944 /* Compute differences in buffer positions, y-positions etc. for
10945 lines reused at the bottom of the window. Compute what we can
10947 if (first_unchanged_at_end_row
10948 /* No lines reused because we displayed everything up to the
10949 bottom of the window. */
10950 && it
.current_y
< it
.last_visible_y
)
10953 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
10955 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
10956 run
.current_y
= first_unchanged_at_end_row
->y
;
10957 run
.desired_y
= run
.current_y
+ dy
;
10958 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
10962 delta
= dvpos
= dy
= run
.current_y
= run
.desired_y
= run
.height
= 0;
10963 first_unchanged_at_end_row
= NULL
;
10965 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
10968 /* Find the cursor if not already found. We have to decide whether
10969 PT will appear on this window (it sometimes doesn't, but this is
10970 not a very frequent case.) This decision has to be made before
10971 the current matrix is altered. A value of cursor.vpos < 0 means
10972 that PT is either in one of the lines beginning at
10973 first_unchanged_at_end_row or below the window. Don't care for
10974 lines that might be displayed later at the window end; as
10975 mentioned, this is not a frequent case. */
10976 if (w
->cursor
.vpos
< 0)
10978 /* Cursor in unchanged rows at the top? */
10979 if (PT
< CHARPOS (start_pos
)
10980 && last_unchanged_at_beg_row
)
10982 row
= row_containing_pos (w
, PT
,
10983 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
10984 last_unchanged_at_beg_row
+ 1);
10986 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
10989 /* Start from first_unchanged_at_end_row looking for PT. */
10990 else if (first_unchanged_at_end_row
)
10992 row
= row_containing_pos (w
, PT
- delta
,
10993 first_unchanged_at_end_row
, NULL
);
10995 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
10996 delta_bytes
, dy
, dvpos
);
10999 /* Give up if cursor was not found. */
11000 if (w
->cursor
.vpos
< 0)
11002 clear_glyph_matrix (w
->desired_matrix
);
11007 /* Don't let the cursor end in the scroll margins. */
11009 int this_scroll_margin
, cursor_height
;
11011 this_scroll_margin
= max (0, scroll_margin
);
11012 this_scroll_margin
= min (this_scroll_margin
,
11013 XFASTINT (w
->height
) / 4);
11014 this_scroll_margin
*= CANON_Y_UNIT (it
.f
);
11015 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
11017 if ((w
->cursor
.y
< this_scroll_margin
11018 && CHARPOS (start
) > BEGV
)
11019 /* Don't take scroll margin into account at the bottom because
11020 old redisplay didn't do it either. */
11021 || w
->cursor
.y
+ cursor_height
> it
.last_visible_y
)
11023 w
->cursor
.vpos
= -1;
11024 clear_glyph_matrix (w
->desired_matrix
);
11029 /* Scroll the display. Do it before changing the current matrix so
11030 that xterm.c doesn't get confused about where the cursor glyph is
11032 if (dy
&& run
.height
)
11036 if (FRAME_WINDOW_P (f
))
11038 rif
->update_window_begin_hook (w
);
11039 rif
->clear_mouse_face (w
);
11040 rif
->scroll_run_hook (w
, &run
);
11041 rif
->update_window_end_hook (w
, 0, 0);
11045 /* Terminal frame. In this case, dvpos gives the number of
11046 lines to scroll by; dvpos < 0 means scroll up. */
11047 int first_unchanged_at_end_vpos
11048 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
11049 int from
= XFASTINT (w
->top
) + first_unchanged_at_end_vpos
;
11050 int end
= XFASTINT (w
->top
) + window_internal_height (w
);
11052 /* Perform the operation on the screen. */
11055 /* Scroll last_unchanged_at_beg_row to the end of the
11056 window down dvpos lines. */
11057 set_terminal_window (end
);
11059 /* On dumb terminals delete dvpos lines at the end
11060 before inserting dvpos empty lines. */
11061 if (!scroll_region_ok
)
11062 ins_del_lines (end
- dvpos
, -dvpos
);
11064 /* Insert dvpos empty lines in front of
11065 last_unchanged_at_beg_row. */
11066 ins_del_lines (from
, dvpos
);
11068 else if (dvpos
< 0)
11070 /* Scroll up last_unchanged_at_beg_vpos to the end of
11071 the window to last_unchanged_at_beg_vpos - |dvpos|. */
11072 set_terminal_window (end
);
11074 /* Delete dvpos lines in front of
11075 last_unchanged_at_beg_vpos. ins_del_lines will set
11076 the cursor to the given vpos and emit |dvpos| delete
11078 ins_del_lines (from
+ dvpos
, dvpos
);
11080 /* On a dumb terminal insert dvpos empty lines at the
11082 if (!scroll_region_ok
)
11083 ins_del_lines (end
+ dvpos
, -dvpos
);
11086 set_terminal_window (0);
11092 /* Shift reused rows of the current matrix to the right position.
11093 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
11095 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
11096 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
11099 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
11100 bottom_vpos
, dvpos
);
11101 enable_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
11104 else if (dvpos
> 0)
11106 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
11107 bottom_vpos
, dvpos
);
11108 enable_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
11109 first_unchanged_at_end_vpos
+ dvpos
, 0);
11112 /* For frame-based redisplay, make sure that current frame and window
11113 matrix are in sync with respect to glyph memory. */
11114 if (!FRAME_WINDOW_P (f
))
11115 sync_frame_with_window_matrix_rows (w
);
11117 /* Adjust buffer positions in reused rows. */
11119 increment_matrix_positions (current_matrix
,
11120 first_unchanged_at_end_vpos
+ dvpos
,
11121 bottom_vpos
, delta
, delta_bytes
);
11123 /* Adjust Y positions. */
11125 shift_glyph_matrix (w
, current_matrix
,
11126 first_unchanged_at_end_vpos
+ dvpos
,
11129 if (first_unchanged_at_end_row
)
11130 first_unchanged_at_end_row
+= dvpos
;
11132 /* If scrolling up, there may be some lines to display at the end of
11134 last_text_row_at_end
= NULL
;
11137 /* Set last_row to the glyph row in the current matrix where the
11138 window end line is found. It has been moved up or down in
11139 the matrix by dvpos. */
11140 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
11141 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
11143 /* If last_row is the window end line, it should display text. */
11144 xassert (last_row
->displays_text_p
);
11146 /* If window end line was partially visible before, begin
11147 displaying at that line. Otherwise begin displaying with the
11148 line following it. */
11149 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
11151 init_to_row_start (&it
, w
, last_row
);
11152 it
.vpos
= last_vpos
;
11153 it
.current_y
= last_row
->y
;
11157 init_to_row_end (&it
, w
, last_row
);
11158 it
.vpos
= 1 + last_vpos
;
11159 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
11163 /* We may start in a continuation line. If so, we have to get
11164 the right continuation_lines_width and current_x. */
11165 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
11166 it
.hpos
= it
.current_x
= 0;
11168 /* Display the rest of the lines at the window end. */
11169 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
11170 while (it
.current_y
< it
.last_visible_y
11171 && !fonts_changed_p
)
11173 /* Is it always sure that the display agrees with lines in
11174 the current matrix? I don't think so, so we mark rows
11175 displayed invalid in the current matrix by setting their
11176 enabled_p flag to zero. */
11177 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
11178 if (display_line (&it
))
11179 last_text_row_at_end
= it
.glyph_row
- 1;
11183 /* Update window_end_pos and window_end_vpos. */
11184 if (first_unchanged_at_end_row
11185 && first_unchanged_at_end_row
->y
< it
.last_visible_y
11186 && !last_text_row_at_end
)
11188 /* Window end line if one of the preserved rows from the current
11189 matrix. Set row to the last row displaying text in current
11190 matrix starting at first_unchanged_at_end_row, after
11192 xassert (first_unchanged_at_end_row
->displays_text_p
);
11193 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
11194 first_unchanged_at_end_row
);
11195 xassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
11197 XSETFASTINT (w
->window_end_pos
, Z
- MATRIX_ROW_END_CHARPOS (row
));
11198 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
11199 XSETFASTINT (w
->window_end_vpos
,
11200 MATRIX_ROW_VPOS (row
, w
->current_matrix
));
11202 else if (last_text_row_at_end
)
11204 XSETFASTINT (w
->window_end_pos
,
11205 Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
));
11206 w
->window_end_bytepos
11207 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
11208 XSETFASTINT (w
->window_end_vpos
,
11209 MATRIX_ROW_VPOS (last_text_row_at_end
, desired_matrix
));
11211 else if (last_text_row
)
11213 /* We have displayed either to the end of the window or at the
11214 end of the window, i.e. the last row with text is to be found
11215 in the desired matrix. */
11216 XSETFASTINT (w
->window_end_pos
,
11217 Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
11218 w
->window_end_bytepos
11219 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
11220 XSETFASTINT (w
->window_end_vpos
,
11221 MATRIX_ROW_VPOS (last_text_row
, desired_matrix
));
11223 else if (first_unchanged_at_end_row
== NULL
11224 && last_text_row
== NULL
11225 && last_text_row_at_end
== NULL
)
11227 /* Displayed to end of window, but no line containing text was
11228 displayed. Lines were deleted at the end of the window. */
11230 int header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
11232 for (vpos
= XFASTINT (w
->window_end_vpos
); vpos
> 0; --vpos
)
11233 if ((w
->desired_matrix
->rows
[vpos
+ header_line_p
].enabled_p
11234 && w
->desired_matrix
->rows
[vpos
+ header_line_p
].displays_text_p
)
11235 || (!w
->desired_matrix
->rows
[vpos
+ header_line_p
].enabled_p
11236 && w
->current_matrix
->rows
[vpos
+ header_line_p
].displays_text_p
))
11239 w
->window_end_vpos
= make_number (vpos
);
11244 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
11245 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
11247 /* Record that display has not been completed. */
11248 w
->window_end_valid
= Qnil
;
11249 w
->desired_matrix
->no_scrolling_p
= 1;
11255 /***********************************************************************
11256 More debugging support
11257 ***********************************************************************/
11261 void dump_glyph_row
P_ ((struct glyph_matrix
*, int, int));
11262 void dump_glyph_matrix
P_ ((struct glyph_matrix
*, int));
11265 /* Dump the contents of glyph matrix MATRIX on stderr.
11267 GLYPHS 0 means don't show glyph contents.
11268 GLYPHS 1 means show glyphs in short form
11269 GLYPHS > 1 means show glyphs in long form. */
11272 dump_glyph_matrix (matrix
, glyphs
)
11273 struct glyph_matrix
*matrix
;
11277 for (i
= 0; i
< matrix
->nrows
; ++i
)
11278 dump_glyph_row (matrix
, i
, glyphs
);
11282 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
11283 GLYPHS 0 means don't show glyph contents.
11284 GLYPHS 1 means show glyphs in short form
11285 GLYPHS > 1 means show glyphs in long form. */
11288 dump_glyph_row (matrix
, vpos
, glyphs
)
11289 struct glyph_matrix
*matrix
;
11292 struct glyph_row
*row
;
11294 if (vpos
< 0 || vpos
>= matrix
->nrows
)
11297 row
= MATRIX_ROW (matrix
, vpos
);
11301 fprintf (stderr
, "Row Start End Used oEI><O\\CTZFes X Y W H V A P\n");
11302 fprintf (stderr
, "=======================================================================\n");
11304 fprintf (stderr
, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d\
11305 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
11306 row
- matrix
->rows
,
11307 MATRIX_ROW_START_CHARPOS (row
),
11308 MATRIX_ROW_END_CHARPOS (row
),
11309 row
->used
[TEXT_AREA
],
11310 row
->contains_overlapping_glyphs_p
,
11313 row
->truncated_on_left_p
,
11314 row
->truncated_on_right_p
,
11315 row
->overlay_arrow_p
,
11317 MATRIX_ROW_CONTINUATION_LINE_P (row
),
11318 row
->displays_text_p
,
11321 row
->ends_in_middle_of_char_p
,
11322 row
->starts_in_middle_of_char_p
,
11327 row
->visible_height
,
11330 fprintf (stderr
, "%9d %5d\n", row
->start
.overlay_string_index
,
11331 row
->end
.overlay_string_index
);
11332 fprintf (stderr
, "%9d %5d\n",
11333 CHARPOS (row
->start
.string_pos
),
11334 CHARPOS (row
->end
.string_pos
));
11335 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
11336 row
->end
.dpvec_index
);
11341 struct glyph
*glyph
, *glyph_end
;
11342 int prev_had_glyphs_p
;
11344 glyph
= row
->glyphs
[TEXT_AREA
];
11345 glyph_end
= glyph
+ row
->used
[TEXT_AREA
];
11347 /* Glyph for a line end in text. */
11348 if (glyph
== glyph_end
&& glyph
->charpos
> 0)
11351 if (glyph
< glyph_end
)
11353 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
11354 prev_had_glyphs_p
= 1;
11357 prev_had_glyphs_p
= 0;
11359 while (glyph
< glyph_end
)
11361 if (glyph
->type
== CHAR_GLYPH
)
11364 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
11365 glyph
- row
->glyphs
[TEXT_AREA
],
11368 (BUFFERP (glyph
->object
)
11370 : (STRINGP (glyph
->object
)
11373 glyph
->pixel_width
,
11375 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
11379 glyph
->left_box_line_p
,
11380 glyph
->right_box_line_p
);
11382 else if (glyph
->type
== STRETCH_GLYPH
)
11385 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
11386 glyph
- row
->glyphs
[TEXT_AREA
],
11389 (BUFFERP (glyph
->object
)
11391 : (STRINGP (glyph
->object
)
11394 glyph
->pixel_width
,
11398 glyph
->left_box_line_p
,
11399 glyph
->right_box_line_p
);
11401 else if (glyph
->type
== IMAGE_GLYPH
)
11404 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
11405 glyph
- row
->glyphs
[TEXT_AREA
],
11408 (BUFFERP (glyph
->object
)
11410 : (STRINGP (glyph
->object
)
11413 glyph
->pixel_width
,
11417 glyph
->left_box_line_p
,
11418 glyph
->right_box_line_p
);
11423 else if (glyphs
== 1)
11425 char *s
= (char *) alloca (row
->used
[TEXT_AREA
] + 1);
11428 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
11430 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
11431 if (glyph
->type
== CHAR_GLYPH
11432 && glyph
->u
.ch
< 0x80
11433 && glyph
->u
.ch
>= ' ')
11434 s
[i
] = glyph
->u
.ch
;
11440 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
11445 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
11446 Sdump_glyph_matrix
, 0, 1, "p",
11447 "Dump the current matrix of the selected window to stderr.\n\
11448 Shows contents of glyph row structures. With non-nil\n\
11449 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show\n\
11450 glyphs in short form, otherwise show glyphs in long form.")
11452 Lisp_Object glyphs
;
11454 struct window
*w
= XWINDOW (selected_window
);
11455 struct buffer
*buffer
= XBUFFER (w
->buffer
);
11457 fprintf (stderr
, "PT = %d, BEGV = %d. ZV = %d\n",
11458 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
11459 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
11460 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
11461 fprintf (stderr
, "=============================================\n");
11462 dump_glyph_matrix (w
->current_matrix
,
11463 NILP (glyphs
) ? 0 : XINT (glyphs
));
11468 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
11469 "Dump glyph row ROW to stderr.\n\
11470 GLYPH 0 means don't dump glyphs.\n\
11471 GLYPH 1 means dump glyphs in short form.\n\
11472 GLYPH > 1 or omitted means dump glyphs in long form.")
11474 Lisp_Object row
, glyphs
;
11476 CHECK_NUMBER (row
, 0);
11477 dump_glyph_row (XWINDOW (selected_window
)->current_matrix
,
11479 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
11484 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
,
11488 struct frame
*sf
= SELECTED_FRAME ();
11489 struct glyph_matrix
*m
= (XWINDOW (sf
->tool_bar_window
)
11491 dump_glyph_row (m
, 0, 1);
11496 DEFUN ("trace-redisplay-toggle", Ftrace_redisplay_toggle
,
11497 Strace_redisplay_toggle
, 0, 0, "",
11498 "Toggle tracing of redisplay.")
11501 trace_redisplay_p
= !trace_redisplay_p
;
11506 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, 1, "",
11507 "Print STRING to stderr.")
11509 Lisp_Object string
;
11511 CHECK_STRING (string
, 0);
11512 fprintf (stderr
, "%s", XSTRING (string
)->data
);
11516 #endif /* GLYPH_DEBUG */
11520 /***********************************************************************
11521 Building Desired Matrix Rows
11522 ***********************************************************************/
11524 /* Return a temporary glyph row holding the glyphs of an overlay
11525 arrow. Only used for non-window-redisplay windows. */
11527 static struct glyph_row
*
11528 get_overlay_arrow_glyph_row (w
)
11531 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
11532 struct buffer
*buffer
= XBUFFER (w
->buffer
);
11533 struct buffer
*old
= current_buffer
;
11534 unsigned char *arrow_string
= XSTRING (Voverlay_arrow_string
)->data
;
11535 int arrow_len
= XSTRING (Voverlay_arrow_string
)->size
;
11536 unsigned char *arrow_end
= arrow_string
+ arrow_len
;
11540 int n_glyphs_before
;
11542 set_buffer_temp (buffer
);
11543 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
11544 it
.glyph_row
->used
[TEXT_AREA
] = 0;
11545 SET_TEXT_POS (it
.position
, 0, 0);
11547 multibyte_p
= !NILP (buffer
->enable_multibyte_characters
);
11549 while (p
< arrow_end
)
11551 Lisp_Object face
, ilisp
;
11553 /* Get the next character. */
11555 it
.c
= string_char_and_length (p
, arrow_len
, &it
.len
);
11557 it
.c
= *p
, it
.len
= 1;
11560 /* Get its face. */
11561 XSETFASTINT (ilisp
, p
- arrow_string
);
11562 face
= Fget_text_property (ilisp
, Qface
, Voverlay_arrow_string
);
11563 it
.face_id
= compute_char_face (f
, it
.c
, face
);
11565 /* Compute its width, get its glyphs. */
11566 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
11567 SET_TEXT_POS (it
.position
, -1, -1);
11568 PRODUCE_GLYPHS (&it
);
11570 /* If this character doesn't fit any more in the line, we have
11571 to remove some glyphs. */
11572 if (it
.current_x
> it
.last_visible_x
)
11574 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
11579 set_buffer_temp (old
);
11580 return it
.glyph_row
;
11584 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
11585 glyphs are only inserted for terminal frames since we can't really
11586 win with truncation glyphs when partially visible glyphs are
11587 involved. Which glyphs to insert is determined by
11588 produce_special_glyphs. */
11591 insert_left_trunc_glyphs (it
)
11594 struct it truncate_it
;
11595 struct glyph
*from
, *end
, *to
, *toend
;
11597 xassert (!FRAME_WINDOW_P (it
->f
));
11599 /* Get the truncation glyphs. */
11601 truncate_it
.current_x
= 0;
11602 truncate_it
.face_id
= DEFAULT_FACE_ID
;
11603 truncate_it
.glyph_row
= &scratch_glyph_row
;
11604 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
11605 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
11606 truncate_it
.object
= make_number (0);
11607 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
11609 /* Overwrite glyphs from IT with truncation glyphs. */
11610 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
11611 end
= from
+ truncate_it
.glyph_row
->used
[TEXT_AREA
];
11612 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
11613 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
11618 /* There may be padding glyphs left over. Remove them. */
11620 while (from
< toend
&& CHAR_GLYPH_PADDING_P (*from
))
11622 while (from
< toend
)
11625 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
11629 /* Compute the pixel height and width of IT->glyph_row.
11631 Most of the time, ascent and height of a display line will be equal
11632 to the max_ascent and max_height values of the display iterator
11633 structure. This is not the case if
11635 1. We hit ZV without displaying anything. In this case, max_ascent
11636 and max_height will be zero.
11638 2. We have some glyphs that don't contribute to the line height.
11639 (The glyph row flag contributes_to_line_height_p is for future
11640 pixmap extensions).
11642 The first case is easily covered by using default values because in
11643 these cases, the line height does not really matter, except that it
11644 must not be zero. */
11647 compute_line_metrics (it
)
11650 struct glyph_row
*row
= it
->glyph_row
;
11653 if (FRAME_WINDOW_P (it
->f
))
11655 int i
, header_line_height
;
11657 /* The line may consist of one space only, that was added to
11658 place the cursor on it. If so, the row's height hasn't been
11660 if (row
->height
== 0)
11662 if (it
->max_ascent
+ it
->max_descent
== 0)
11663 it
->max_descent
= it
->max_phys_descent
= CANON_Y_UNIT (it
->f
);
11664 row
->ascent
= it
->max_ascent
;
11665 row
->height
= it
->max_ascent
+ it
->max_descent
;
11666 row
->phys_ascent
= it
->max_phys_ascent
;
11667 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
11670 /* Compute the width of this line. */
11671 row
->pixel_width
= row
->x
;
11672 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
11673 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
11675 xassert (row
->pixel_width
>= 0);
11676 xassert (row
->ascent
>= 0 && row
->height
> 0);
11678 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
11679 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
11681 /* If first line's physical ascent is larger than its logical
11682 ascent, use the physical ascent, and make the row taller.
11683 This makes accented characters fully visible. */
11684 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
11685 && row
->phys_ascent
> row
->ascent
)
11687 row
->height
+= row
->phys_ascent
- row
->ascent
;
11688 row
->ascent
= row
->phys_ascent
;
11691 /* Compute how much of the line is visible. */
11692 row
->visible_height
= row
->height
;
11694 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (it
->w
);
11695 if (row
->y
< header_line_height
)
11696 row
->visible_height
-= header_line_height
- row
->y
;
11699 int max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (it
->w
);
11700 if (row
->y
+ row
->height
> max_y
)
11701 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
11706 row
->pixel_width
= row
->used
[TEXT_AREA
];
11707 row
->ascent
= row
->phys_ascent
= 0;
11708 row
->height
= row
->phys_height
= row
->visible_height
= 1;
11711 /* Compute a hash code for this row. */
11713 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
11714 for (i
= 0; i
< row
->used
[area
]; ++i
)
11715 row
->hash
= ((((row
->hash
<< 4) + (row
->hash
>> 24)) & 0x0fffffff)
11716 + row
->glyphs
[area
][i
].u
.val
11717 + row
->glyphs
[area
][i
].face_id
11718 + row
->glyphs
[area
][i
].padding_p
11719 + (row
->glyphs
[area
][i
].type
<< 2));
11721 it
->max_ascent
= it
->max_descent
= 0;
11722 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
11726 /* Append one space to the glyph row of iterator IT if doing a
11727 window-based redisplay. DEFAULT_FACE_P non-zero means let the
11728 space have the default face, otherwise let it have the same face as
11729 IT->face_id. Value is non-zero if a space was added.
11731 This function is called to make sure that there is always one glyph
11732 at the end of a glyph row that the cursor can be set on under
11733 window-systems. (If there weren't such a glyph we would not know
11734 how wide and tall a box cursor should be displayed).
11736 At the same time this space let's a nicely handle clearing to the
11737 end of the line if the row ends in italic text. */
11740 append_space (it
, default_face_p
)
11742 int default_face_p
;
11744 if (FRAME_WINDOW_P (it
->f
))
11746 int n
= it
->glyph_row
->used
[TEXT_AREA
];
11748 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
11749 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
11751 /* Save some values that must not be changed.
11752 Must save IT->c and IT->len because otherwise
11753 ITERATOR_AT_END_P wouldn't work anymore after
11754 append_space has been called. */
11755 int saved_what
= it
->what
;
11756 int saved_c
= it
->c
, saved_len
= it
->len
;
11757 int saved_x
= it
->current_x
;
11758 int saved_face_id
= it
->face_id
;
11759 struct text_pos saved_pos
;
11760 Lisp_Object saved_object
;
11763 saved_object
= it
->object
;
11764 saved_pos
= it
->position
;
11766 it
->what
= IT_CHARACTER
;
11767 bzero (&it
->position
, sizeof it
->position
);
11768 it
->object
= make_number (0);
11772 if (default_face_p
)
11773 it
->face_id
= DEFAULT_FACE_ID
;
11774 else if (it
->face_before_selective_p
)
11775 it
->face_id
= it
->saved_face_id
;
11776 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
11777 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0);
11779 PRODUCE_GLYPHS (it
);
11781 it
->current_x
= saved_x
;
11782 it
->object
= saved_object
;
11783 it
->position
= saved_pos
;
11784 it
->what
= saved_what
;
11785 it
->face_id
= saved_face_id
;
11786 it
->len
= saved_len
;
11796 /* Extend the face of the last glyph in the text area of IT->glyph_row
11797 to the end of the display line. Called from display_line.
11798 If the glyph row is empty, add a space glyph to it so that we
11799 know the face to draw. Set the glyph row flag fill_line_p. */
11802 extend_face_to_end_of_line (it
)
11806 struct frame
*f
= it
->f
;
11808 /* If line is already filled, do nothing. */
11809 if (it
->current_x
>= it
->last_visible_x
)
11812 /* Face extension extends the background and box of IT->face_id
11813 to the end of the line. If the background equals the background
11814 of the frame, we don't have to do anything. */
11815 if (it
->face_before_selective_p
)
11816 face
= FACE_FROM_ID (it
->f
, it
->saved_face_id
);
11818 face
= FACE_FROM_ID (f
, it
->face_id
);
11820 if (FRAME_WINDOW_P (f
)
11821 && face
->box
== FACE_NO_BOX
11822 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
11826 /* Set the glyph row flag indicating that the face of the last glyph
11827 in the text area has to be drawn to the end of the text area. */
11828 it
->glyph_row
->fill_line_p
= 1;
11830 /* If current character of IT is not ASCII, make sure we have the
11831 ASCII face. This will be automatically undone the next time
11832 get_next_display_element returns a multibyte character. Note
11833 that the character will always be single byte in unibyte text. */
11834 if (!SINGLE_BYTE_CHAR_P (it
->c
))
11836 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0);
11839 if (FRAME_WINDOW_P (f
))
11841 /* If the row is empty, add a space with the current face of IT,
11842 so that we know which face to draw. */
11843 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
11845 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
11846 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= it
->face_id
;
11847 it
->glyph_row
->used
[TEXT_AREA
] = 1;
11852 /* Save some values that must not be changed. */
11853 int saved_x
= it
->current_x
;
11854 struct text_pos saved_pos
;
11855 Lisp_Object saved_object
;
11856 int saved_what
= it
->what
;
11857 int saved_face_id
= it
->face_id
;
11859 saved_object
= it
->object
;
11860 saved_pos
= it
->position
;
11862 it
->what
= IT_CHARACTER
;
11863 bzero (&it
->position
, sizeof it
->position
);
11864 it
->object
= make_number (0);
11867 it
->face_id
= face
->id
;
11869 PRODUCE_GLYPHS (it
);
11871 while (it
->current_x
<= it
->last_visible_x
)
11872 PRODUCE_GLYPHS (it
);
11874 /* Don't count these blanks really. It would let us insert a left
11875 truncation glyph below and make us set the cursor on them, maybe. */
11876 it
->current_x
= saved_x
;
11877 it
->object
= saved_object
;
11878 it
->position
= saved_pos
;
11879 it
->what
= saved_what
;
11880 it
->face_id
= saved_face_id
;
11885 /* Value is non-zero if text starting at CHARPOS in current_buffer is
11886 trailing whitespace. */
11889 trailing_whitespace_p (charpos
)
11892 int bytepos
= CHAR_TO_BYTE (charpos
);
11895 while (bytepos
< ZV_BYTE
11896 && (c
= FETCH_CHAR (bytepos
),
11897 c
== ' ' || c
== '\t'))
11900 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
11902 if (bytepos
!= PT_BYTE
)
11909 /* Highlight trailing whitespace, if any, in ROW. */
11912 highlight_trailing_whitespace (f
, row
)
11914 struct glyph_row
*row
;
11916 int used
= row
->used
[TEXT_AREA
];
11920 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
11921 struct glyph
*glyph
= start
+ used
- 1;
11923 /* Skip over the space glyph inserted to display the
11924 cursor at the end of a line. */
11925 if (glyph
->type
== CHAR_GLYPH
11926 && glyph
->u
.ch
== ' '
11927 && INTEGERP (glyph
->object
))
11930 /* If last glyph is a space or stretch, and it's trailing
11931 whitespace, set the face of all trailing whitespace glyphs in
11932 IT->glyph_row to `trailing-whitespace'. */
11934 && BUFFERP (glyph
->object
)
11935 && (glyph
->type
== STRETCH_GLYPH
11936 || (glyph
->type
== CHAR_GLYPH
11937 && glyph
->u
.ch
== ' '))
11938 && trailing_whitespace_p (glyph
->charpos
))
11940 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
11942 while (glyph
>= start
11943 && BUFFERP (glyph
->object
)
11944 && (glyph
->type
== STRETCH_GLYPH
11945 || (glyph
->type
== CHAR_GLYPH
11946 && glyph
->u
.ch
== ' ')))
11947 (glyph
--)->face_id
= face_id
;
11953 /* Value is non-zero if glyph row ROW in window W should be
11954 used to hold the cursor. */
11957 cursor_row_p (w
, row
)
11959 struct glyph_row
*row
;
11961 int cursor_row_p
= 1;
11963 if (PT
== MATRIX_ROW_END_CHARPOS (row
))
11965 /* If the row ends with a newline from a string, we don't want
11966 the cursor there (if the row is continued it doesn't end in a
11968 if (CHARPOS (row
->end
.string_pos
) >= 0
11969 || MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
11970 cursor_row_p
= row
->continued_p
;
11972 /* If the row ends at ZV, display the cursor at the end of that
11973 row instead of at the start of the row below. */
11974 else if (row
->ends_at_zv_p
)
11980 return cursor_row_p
;
11984 /* Construct the glyph row IT->glyph_row in the desired matrix of
11985 IT->w from text at the current position of IT. See dispextern.h
11986 for an overview of struct it. Value is non-zero if
11987 IT->glyph_row displays text, as opposed to a line displaying ZV
11994 struct glyph_row
*row
= it
->glyph_row
;
11996 /* We always start displaying at hpos zero even if hscrolled. */
11997 xassert (it
->hpos
== 0 && it
->current_x
== 0);
11999 /* We must not display in a row that's not a text row. */
12000 xassert (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
12001 < it
->w
->desired_matrix
->nrows
);
12003 /* Is IT->w showing the region? */
12004 it
->w
->region_showing
= it
->region_beg_charpos
> 0 ? Qt
: Qnil
;
12006 /* Clear the result glyph row and enable it. */
12007 prepare_desired_row (row
);
12009 row
->y
= it
->current_y
;
12010 row
->start
= it
->current
;
12011 row
->continuation_lines_width
= it
->continuation_lines_width
;
12012 row
->displays_text_p
= 1;
12013 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
12014 it
->starts_in_middle_of_char_p
= 0;
12016 /* Arrange the overlays nicely for our purposes. Usually, we call
12017 display_line on only one line at a time, in which case this
12018 can't really hurt too much, or we call it on lines which appear
12019 one after another in the buffer, in which case all calls to
12020 recenter_overlay_lists but the first will be pretty cheap. */
12021 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
12023 /* Move over display elements that are not visible because we are
12024 hscrolled. This may stop at an x-position < IT->first_visible_x
12025 if the first glyph is partially visible or if we hit a line end. */
12026 if (it
->current_x
< it
->first_visible_x
)
12027 move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
12028 MOVE_TO_POS
| MOVE_TO_X
);
12030 /* Get the initial row height. This is either the height of the
12031 text hscrolled, if there is any, or zero. */
12032 row
->ascent
= it
->max_ascent
;
12033 row
->height
= it
->max_ascent
+ it
->max_descent
;
12034 row
->phys_ascent
= it
->max_phys_ascent
;
12035 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
12037 /* Loop generating characters. The loop is left with IT on the next
12038 character to display. */
12041 int n_glyphs_before
, hpos_before
, x_before
;
12043 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
12045 /* Retrieve the next thing to display. Value is zero if end of
12047 if (!get_next_display_element (it
))
12049 /* Maybe add a space at the end of this line that is used to
12050 display the cursor there under X. Set the charpos of the
12051 first glyph of blank lines not corresponding to any text
12053 if ((append_space (it
, 1) && row
->used
[TEXT_AREA
] == 1)
12054 || row
->used
[TEXT_AREA
] == 0)
12056 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
12057 row
->displays_text_p
= 0;
12059 if (!NILP (XBUFFER (it
->w
->buffer
)->indicate_empty_lines
))
12060 row
->indicate_empty_line_p
= 1;
12063 it
->continuation_lines_width
= 0;
12064 row
->ends_at_zv_p
= 1;
12068 /* Now, get the metrics of what we want to display. This also
12069 generates glyphs in `row' (which is IT->glyph_row). */
12070 n_glyphs_before
= row
->used
[TEXT_AREA
];
12073 /* Remember the line height so far in case the next element doesn't
12074 fit on the line. */
12075 if (!it
->truncate_lines_p
)
12077 ascent
= it
->max_ascent
;
12078 descent
= it
->max_descent
;
12079 phys_ascent
= it
->max_phys_ascent
;
12080 phys_descent
= it
->max_phys_descent
;
12083 PRODUCE_GLYPHS (it
);
12085 /* If this display element was in marginal areas, continue with
12087 if (it
->area
!= TEXT_AREA
)
12089 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
12090 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
12091 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
12092 row
->phys_height
= max (row
->phys_height
,
12093 it
->max_phys_ascent
+ it
->max_phys_descent
);
12094 set_iterator_to_next (it
, 1);
12098 /* Does the display element fit on the line? If we truncate
12099 lines, we should draw past the right edge of the window. If
12100 we don't truncate, we want to stop so that we can display the
12101 continuation glyph before the right margin. If lines are
12102 continued, there are two possible strategies for characters
12103 resulting in more than 1 glyph (e.g. tabs): Display as many
12104 glyphs as possible in this line and leave the rest for the
12105 continuation line, or display the whole element in the next
12106 line. Original redisplay did the former, so we do it also. */
12107 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
12108 hpos_before
= it
->hpos
;
12112 && it
->current_x
< it
->last_visible_x
)
12115 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
12116 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
12117 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
12118 row
->phys_height
= max (row
->phys_height
,
12119 it
->max_phys_ascent
+ it
->max_phys_descent
);
12120 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
12121 row
->x
= x
- it
->first_visible_x
;
12126 struct glyph
*glyph
;
12128 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
12130 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
12131 new_x
= x
+ glyph
->pixel_width
;
12133 if (/* Lines are continued. */
12134 !it
->truncate_lines_p
12135 && (/* Glyph doesn't fit on the line. */
12136 new_x
> it
->last_visible_x
12137 /* Or it fits exactly on a window system frame. */
12138 || (new_x
== it
->last_visible_x
12139 && FRAME_WINDOW_P (it
->f
))))
12141 /* End of a continued line. */
12144 || (new_x
== it
->last_visible_x
12145 && FRAME_WINDOW_P (it
->f
)))
12147 /* Current glyph is the only one on the line or
12148 fits exactly on the line. We must continue
12149 the line because we can't draw the cursor
12150 after the glyph. */
12151 row
->continued_p
= 1;
12152 it
->current_x
= new_x
;
12153 it
->continuation_lines_width
+= new_x
;
12155 if (i
== nglyphs
- 1)
12156 set_iterator_to_next (it
, 1);
12158 else if (CHAR_GLYPH_PADDING_P (*glyph
)
12159 && !FRAME_WINDOW_P (it
->f
))
12161 /* A padding glyph that doesn't fit on this line.
12162 This means the whole character doesn't fit
12164 row
->used
[TEXT_AREA
] = n_glyphs_before
;
12166 /* Fill the rest of the row with continuation
12167 glyphs like in 20.x. */
12168 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
12169 < row
->glyphs
[1 + TEXT_AREA
])
12170 produce_special_glyphs (it
, IT_CONTINUATION
);
12172 row
->continued_p
= 1;
12173 it
->current_x
= x_before
;
12174 it
->continuation_lines_width
+= x_before
;
12176 /* Restore the height to what it was before the
12177 element not fitting on the line. */
12178 it
->max_ascent
= ascent
;
12179 it
->max_descent
= descent
;
12180 it
->max_phys_ascent
= phys_ascent
;
12181 it
->max_phys_descent
= phys_descent
;
12185 /* Display element draws past the right edge of
12186 the window. Restore positions to values
12187 before the element. The next line starts
12188 with current_x before the glyph that could
12189 not be displayed, so that TAB works right. */
12190 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
12192 /* Display continuation glyphs. */
12193 if (!FRAME_WINDOW_P (it
->f
))
12194 produce_special_glyphs (it
, IT_CONTINUATION
);
12195 row
->continued_p
= 1;
12198 it
->continuation_lines_width
+= x
;
12199 if (nglyphs
> 1 && i
> 0)
12201 row
->ends_in_middle_of_char_p
= 1;
12202 it
->starts_in_middle_of_char_p
= 1;
12205 /* Restore the height to what it was before the
12206 element not fitting on the line. */
12207 it
->max_ascent
= ascent
;
12208 it
->max_descent
= descent
;
12209 it
->max_phys_ascent
= phys_ascent
;
12210 it
->max_phys_descent
= phys_descent
;
12215 else if (new_x
> it
->first_visible_x
)
12217 /* Increment number of glyphs actually displayed. */
12220 if (x
< it
->first_visible_x
)
12221 /* Glyph is partially visible, i.e. row starts at
12222 negative X position. */
12223 row
->x
= x
- it
->first_visible_x
;
12227 /* Glyph is completely off the left margin of the
12228 window. This should not happen because of the
12229 move_it_in_display_line at the start of
12235 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
12236 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
12237 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
12238 row
->phys_height
= max (row
->phys_height
,
12239 it
->max_phys_ascent
+ it
->max_phys_descent
);
12241 /* End of this display line if row is continued. */
12242 if (row
->continued_p
)
12246 /* Is this a line end? If yes, we're also done, after making
12247 sure that a non-default face is extended up to the right
12248 margin of the window. */
12249 if (ITERATOR_AT_END_OF_LINE_P (it
))
12251 int used_before
= row
->used
[TEXT_AREA
];
12253 /* Add a space at the end of the line that is used to
12254 display the cursor there. */
12255 append_space (it
, 0);
12257 /* Extend the face to the end of the line. */
12258 extend_face_to_end_of_line (it
);
12260 /* Make sure we have the position. */
12261 if (used_before
== 0)
12262 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
12264 /* Consume the line end. This skips over invisible lines. */
12265 set_iterator_to_next (it
, 1);
12266 it
->continuation_lines_width
= 0;
12270 /* Proceed with next display element. Note that this skips
12271 over lines invisible because of selective display. */
12272 set_iterator_to_next (it
, 1);
12274 /* If we truncate lines, we are done when the last displayed
12275 glyphs reach past the right margin of the window. */
12276 if (it
->truncate_lines_p
12277 && (FRAME_WINDOW_P (it
->f
)
12278 ? (it
->current_x
>= it
->last_visible_x
)
12279 : (it
->current_x
> it
->last_visible_x
)))
12281 /* Maybe add truncation glyphs. */
12282 if (!FRAME_WINDOW_P (it
->f
))
12284 --it
->glyph_row
->used
[TEXT_AREA
];
12285 produce_special_glyphs (it
, IT_TRUNCATION
);
12288 row
->truncated_on_right_p
= 1;
12289 it
->continuation_lines_width
= 0;
12290 reseat_at_next_visible_line_start (it
, 0);
12291 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
12292 it
->hpos
= hpos_before
;
12293 it
->current_x
= x_before
;
12298 /* If line is not empty and hscrolled, maybe insert truncation glyphs
12299 at the left window margin. */
12300 if (it
->first_visible_x
12301 && IT_CHARPOS (*it
) != MATRIX_ROW_START_CHARPOS (row
))
12303 if (!FRAME_WINDOW_P (it
->f
))
12304 insert_left_trunc_glyphs (it
);
12305 row
->truncated_on_left_p
= 1;
12308 /* If the start of this line is the overlay arrow-position, then
12309 mark this glyph row as the one containing the overlay arrow.
12310 This is clearly a mess with variable size fonts. It would be
12311 better to let it be displayed like cursors under X. */
12312 if (MARKERP (Voverlay_arrow_position
)
12313 && current_buffer
== XMARKER (Voverlay_arrow_position
)->buffer
12314 && (MATRIX_ROW_START_CHARPOS (row
)
12315 == marker_position (Voverlay_arrow_position
))
12316 && STRINGP (Voverlay_arrow_string
)
12317 && ! overlay_arrow_seen
)
12319 /* Overlay arrow in window redisplay is a bitmap. */
12320 if (!FRAME_WINDOW_P (it
->f
))
12322 struct glyph_row
*arrow_row
= get_overlay_arrow_glyph_row (it
->w
);
12323 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
12324 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
12325 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
12326 struct glyph
*p2
, *end
;
12328 /* Copy the arrow glyphs. */
12329 while (glyph
< arrow_end
)
12332 /* Throw away padding glyphs. */
12334 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
12335 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
12341 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
12345 overlay_arrow_seen
= 1;
12346 row
->overlay_arrow_p
= 1;
12349 /* Compute pixel dimensions of this line. */
12350 compute_line_metrics (it
);
12352 /* Remember the position at which this line ends. */
12353 row
->end
= it
->current
;
12355 /* Maybe set the cursor. */
12356 if (it
->w
->cursor
.vpos
< 0
12357 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
12358 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
12359 && cursor_row_p (it
->w
, row
))
12360 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
12362 /* Highlight trailing whitespace. */
12363 if (!NILP (Vshow_trailing_whitespace
))
12364 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
12366 /* Prepare for the next line. This line starts horizontally at (X
12367 HPOS) = (0 0). Vertical positions are incremented. As a
12368 convenience for the caller, IT->glyph_row is set to the next
12370 it
->current_x
= it
->hpos
= 0;
12371 it
->current_y
+= row
->height
;
12374 return row
->displays_text_p
;
12379 /***********************************************************************
12381 ***********************************************************************/
12383 /* Redisplay the menu bar in the frame for window W.
12385 The menu bar of X frames that don't have X toolkit support is
12386 displayed in a special window W->frame->menu_bar_window.
12388 The menu bar of terminal frames is treated specially as far as
12389 glyph matrices are concerned. Menu bar lines are not part of
12390 windows, so the update is done directly on the frame matrix rows
12391 for the menu bar. */
12394 display_menu_bar (w
)
12397 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
12402 /* Don't do all this for graphical frames. */
12404 if (!NILP (Vwindow_system
))
12407 #ifdef USE_X_TOOLKIT
12412 if (FRAME_MAC_P (f
))
12416 #ifdef USE_X_TOOLKIT
12417 xassert (!FRAME_WINDOW_P (f
));
12418 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
12419 it
.first_visible_x
= 0;
12420 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
12421 #else /* not USE_X_TOOLKIT */
12422 if (FRAME_WINDOW_P (f
))
12424 /* Menu bar lines are displayed in the desired matrix of the
12425 dummy window menu_bar_window. */
12426 struct window
*menu_w
;
12427 xassert (WINDOWP (f
->menu_bar_window
));
12428 menu_w
= XWINDOW (f
->menu_bar_window
);
12429 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
12431 it
.first_visible_x
= 0;
12432 it
.last_visible_x
= FRAME_WINDOW_WIDTH (f
) * CANON_X_UNIT (f
);
12436 /* This is a TTY frame, i.e. character hpos/vpos are used as
12438 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
12440 it
.first_visible_x
= 0;
12441 it
.last_visible_x
= FRAME_WIDTH (f
);
12443 #endif /* not USE_X_TOOLKIT */
12445 if (! mode_line_inverse_video
)
12446 /* Force the menu-bar to be displayed in the default face. */
12447 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
12449 /* Clear all rows of the menu bar. */
12450 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
12452 struct glyph_row
*row
= it
.glyph_row
+ i
;
12453 clear_glyph_row (row
);
12454 row
->enabled_p
= 1;
12455 row
->full_width_p
= 1;
12458 /* Display all items of the menu bar. */
12459 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
12460 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
12462 Lisp_Object string
;
12464 /* Stop at nil string. */
12465 string
= XVECTOR (items
)->contents
[i
+ 1];
12469 /* Remember where item was displayed. */
12470 XSETFASTINT (XVECTOR (items
)->contents
[i
+ 3], it
.hpos
);
12472 /* Display the item, pad with one space. */
12473 if (it
.current_x
< it
.last_visible_x
)
12474 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
12475 XSTRING (string
)->size
+ 1, 0, 0, -1);
12478 /* Fill out the line with spaces. */
12479 if (it
.current_x
< it
.last_visible_x
)
12480 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
12482 /* Compute the total height of the lines. */
12483 compute_line_metrics (&it
);
12488 /***********************************************************************
12490 ***********************************************************************/
12492 /* Redisplay mode lines in the window tree whose root is WINDOW. If
12493 FORCE is non-zero, redisplay mode lines unconditionally.
12494 Otherwise, redisplay only mode lines that are garbaged. Value is
12495 the number of windows whose mode lines were redisplayed. */
12498 redisplay_mode_lines (window
, force
)
12499 Lisp_Object window
;
12504 while (!NILP (window
))
12506 struct window
*w
= XWINDOW (window
);
12508 if (WINDOWP (w
->hchild
))
12509 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
12510 else if (WINDOWP (w
->vchild
))
12511 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
12513 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
12514 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
12516 Lisp_Object old_selected_frame
;
12517 struct text_pos lpoint
;
12518 struct buffer
*old
= current_buffer
;
12520 /* Set the window's buffer for the mode line display. */
12521 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
12522 set_buffer_internal_1 (XBUFFER (w
->buffer
));
12524 /* Point refers normally to the selected window. For any
12525 other window, set up appropriate value. */
12526 if (!EQ (window
, selected_window
))
12528 struct text_pos pt
;
12530 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
12531 if (CHARPOS (pt
) < BEGV
)
12532 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
12533 else if (CHARPOS (pt
) > (ZV
- 1))
12534 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
12536 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
12539 /* Temporarily set up the selected frame. */
12540 old_selected_frame
= selected_frame
;
12541 selected_frame
= w
->frame
;
12543 /* Display mode lines. */
12544 clear_glyph_matrix (w
->desired_matrix
);
12545 if (display_mode_lines (w
))
12548 w
->must_be_updated_p
= 1;
12551 /* Restore old settings. */
12552 selected_frame
= old_selected_frame
;
12553 set_buffer_internal_1 (old
);
12554 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
12564 /* Display the mode and/or top line of window W. Value is the number
12565 of mode lines displayed. */
12568 display_mode_lines (w
)
12573 /* These will be set while the mode line specs are processed. */
12574 line_number_displayed
= 0;
12575 w
->column_number_displayed
= Qnil
;
12577 if (WINDOW_WANTS_MODELINE_P (w
))
12579 display_mode_line (w
, MODE_LINE_FACE_ID
,
12580 current_buffer
->mode_line_format
);
12584 if (WINDOW_WANTS_HEADER_LINE_P (w
))
12586 display_mode_line (w
, HEADER_LINE_FACE_ID
,
12587 current_buffer
->header_line_format
);
12595 /* Display mode or top line of window W. FACE_ID specifies which line
12596 to display; it is either MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID.
12597 FORMAT is the mode line format to display. Value is the pixel
12598 height of the mode line displayed. */
12601 display_mode_line (w
, face_id
, format
)
12603 enum face_id face_id
;
12604 Lisp_Object format
;
12609 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
12610 prepare_desired_row (it
.glyph_row
);
12612 if (! mode_line_inverse_video
)
12613 /* Force the mode-line to be displayed in the default face. */
12614 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
12616 /* Temporarily make frame's keyboard the current kboard so that
12617 kboard-local variables in the mode_line_format will get the right
12619 push_frame_kboard (it
.f
);
12620 display_mode_element (&it
, 0, 0, 0, format
);
12621 pop_frame_kboard ();
12623 /* Fill up with spaces. */
12624 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
12626 compute_line_metrics (&it
);
12627 it
.glyph_row
->full_width_p
= 1;
12628 it
.glyph_row
->mode_line_p
= 1;
12629 it
.glyph_row
->inverse_p
= 0;
12630 it
.glyph_row
->continued_p
= 0;
12631 it
.glyph_row
->truncated_on_left_p
= 0;
12632 it
.glyph_row
->truncated_on_right_p
= 0;
12634 /* Make a 3D mode-line have a shadow at its right end. */
12635 face
= FACE_FROM_ID (it
.f
, face_id
);
12636 extend_face_to_end_of_line (&it
);
12637 if (face
->box
!= FACE_NO_BOX
)
12639 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
12640 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
12641 last
->right_box_line_p
= 1;
12644 return it
.glyph_row
->height
;
12648 /* Contribute ELT to the mode line for window IT->w. How it
12649 translates into text depends on its data type.
12651 IT describes the display environment in which we display, as usual.
12653 DEPTH is the depth in recursion. It is used to prevent
12654 infinite recursion here.
12656 FIELD_WIDTH is the number of characters the display of ELT should
12657 occupy in the mode line, and PRECISION is the maximum number of
12658 characters to display from ELT's representation. See
12659 display_string for details. *
12661 Returns the hpos of the end of the text generated by ELT. */
12664 display_mode_element (it
, depth
, field_width
, precision
, elt
)
12667 int field_width
, precision
;
12670 int n
= 0, field
, prec
;
12678 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
12682 /* A string: output it and check for %-constructs within it. */
12684 unsigned char *this = XSTRING (elt
)->data
;
12685 unsigned char *lisp_string
= this;
12687 while ((precision
<= 0 || n
< precision
)
12689 && (frame_title_ptr
12690 || it
->current_x
< it
->last_visible_x
))
12692 unsigned char *last
= this;
12694 /* Advance to end of string or next format specifier. */
12695 while ((c
= *this++) != '\0' && c
!= '%')
12698 if (this - 1 != last
)
12700 /* Output to end of string or up to '%'. Field width
12701 is length of string. Don't output more than
12702 PRECISION allows us. */
12703 prec
= --this - last
;
12704 if (precision
> 0 && prec
> precision
- n
)
12705 prec
= precision
- n
;
12707 if (frame_title_ptr
)
12708 n
+= store_frame_title (last
, prec
, prec
);
12710 n
+= display_string (NULL
, elt
, Qnil
, 0, last
- lisp_string
,
12711 it
, 0, prec
, 0, -1);
12713 else /* c == '%' */
12715 unsigned char *percent_position
= this;
12717 /* Get the specified minimum width. Zero means
12720 while ((c
= *this++) >= '0' && c
<= '9')
12721 field
= field
* 10 + c
- '0';
12723 /* Don't pad beyond the total padding allowed. */
12724 if (field_width
- n
> 0 && field
> field_width
- n
)
12725 field
= field_width
- n
;
12727 /* Note that either PRECISION <= 0 or N < PRECISION. */
12728 prec
= precision
- n
;
12731 n
+= display_mode_element (it
, depth
, field
, prec
,
12732 Vglobal_mode_string
);
12735 unsigned char *spec
12736 = decode_mode_spec (it
->w
, c
, field
, prec
);
12738 if (frame_title_ptr
)
12739 n
+= store_frame_title (spec
, field
, prec
);
12743 = it
->glyph_row
->used
[TEXT_AREA
];
12745 = percent_position
- XSTRING (elt
)->data
;
12747 = display_string (spec
, Qnil
, elt
, charpos
, 0, it
,
12748 field
, prec
, 0, -1);
12750 /* Assign to the glyphs written above the
12751 string where the `%x' came from, position
12755 struct glyph
*glyph
12756 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
12760 for (i
= 0; i
< nwritten
; ++i
)
12762 glyph
[i
].object
= elt
;
12763 glyph
[i
].charpos
= charpos
;
12776 /* A symbol: process the value of the symbol recursively
12777 as if it appeared here directly. Avoid error if symbol void.
12778 Special case: if value of symbol is a string, output the string
12781 register Lisp_Object tem
;
12782 tem
= Fboundp (elt
);
12785 tem
= Fsymbol_value (elt
);
12786 /* If value is a string, output that string literally:
12787 don't check for % within it. */
12790 prec
= XSTRING (tem
)->size
;
12791 if (precision
> 0 && prec
> precision
- n
)
12792 prec
= precision
- n
;
12793 if (frame_title_ptr
)
12794 n
+= store_frame_title (XSTRING (tem
)->data
, -1, prec
);
12796 n
+= display_string (NULL
, tem
, Qnil
, 0, 0, it
,
12799 else if (!EQ (tem
, elt
))
12801 /* Give up right away for nil or t. */
12811 register Lisp_Object car
, tem
;
12813 /* A cons cell: three distinct cases.
12814 If first element is a string or a cons, process all the elements
12815 and effectively concatenate them.
12816 If first element is a negative number, truncate displaying cdr to
12817 at most that many characters. If positive, pad (with spaces)
12818 to at least that many characters.
12819 If first element is a symbol, process the cadr or caddr recursively
12820 according to whether the symbol's value is non-nil or nil. */
12822 if (EQ (car
, QCeval
) && CONSP (XCDR (elt
)))
12824 /* An element of the form (:eval FORM) means evaluate FORM
12825 and use the result as mode line elements. */
12826 struct gcpro gcpro1
;
12829 spec
= safe_eval (XCAR (XCDR (elt
)));
12831 n
+= display_mode_element (it
, depth
, field_width
- n
,
12832 precision
- n
, spec
);
12835 else if (SYMBOLP (car
))
12837 tem
= Fboundp (car
);
12841 /* elt is now the cdr, and we know it is a cons cell.
12842 Use its car if CAR has a non-nil value. */
12845 tem
= Fsymbol_value (car
);
12852 /* Symbol's value is nil (or symbol is unbound)
12853 Get the cddr of the original list
12854 and if possible find the caddr and use that. */
12858 else if (!CONSP (elt
))
12863 else if (INTEGERP (car
))
12865 register int lim
= XINT (car
);
12869 /* Negative int means reduce maximum width. */
12870 if (precision
<= 0)
12873 precision
= min (precision
, -lim
);
12877 /* Padding specified. Don't let it be more than
12878 current maximum. */
12880 lim
= min (precision
, lim
);
12882 /* If that's more padding than already wanted, queue it.
12883 But don't reduce padding already specified even if
12884 that is beyond the current truncation point. */
12885 field_width
= max (lim
, field_width
);
12889 else if (STRINGP (car
) || CONSP (car
))
12891 register int limit
= 50;
12892 /* Limit is to protect against circular lists. */
12895 && (precision
<= 0 || n
< precision
))
12897 n
+= display_mode_element (it
, depth
, field_width
- n
,
12898 precision
- n
, XCAR (elt
));
12907 if (frame_title_ptr
)
12908 n
+= store_frame_title ("*invalid*", 0, precision
- n
);
12910 n
+= display_string ("*invalid*", Qnil
, Qnil
, 0, 0, it
, 0,
12911 precision
- n
, 0, 0);
12915 /* Pad to FIELD_WIDTH. */
12916 if (field_width
> 0 && n
< field_width
)
12918 if (frame_title_ptr
)
12919 n
+= store_frame_title ("", field_width
- n
, 0);
12921 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
12929 /* Write a null-terminated, right justified decimal representation of
12930 the positive integer D to BUF using a minimal field width WIDTH. */
12933 pint2str (buf
, width
, d
)
12934 register char *buf
;
12935 register int width
;
12938 register char *p
= buf
;
12946 *p
++ = d
% 10 + '0';
12951 for (width
-= (int) (p
- buf
); width
> 0; --width
)
12962 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
12963 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
12964 type of CODING_SYSTEM. Return updated pointer into BUF. */
12966 static unsigned char invalid_eol_type
[] = "(*invalid*)";
12969 decode_mode_spec_coding (coding_system
, buf
, eol_flag
)
12970 Lisp_Object coding_system
;
12971 register char *buf
;
12975 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
12976 unsigned char *eol_str
;
12978 /* The EOL conversion we are using. */
12979 Lisp_Object eoltype
;
12981 val
= Fget (coding_system
, Qcoding_system
);
12984 if (!VECTORP (val
)) /* Not yet decided. */
12989 eoltype
= eol_mnemonic_undecided
;
12990 /* Don't mention EOL conversion if it isn't decided. */
12994 Lisp_Object eolvalue
;
12996 eolvalue
= Fget (coding_system
, Qeol_type
);
12999 *buf
++ = XFASTINT (XVECTOR (val
)->contents
[1]);
13003 /* The EOL conversion that is normal on this system. */
13005 if (NILP (eolvalue
)) /* Not yet decided. */
13006 eoltype
= eol_mnemonic_undecided
;
13007 else if (VECTORP (eolvalue
)) /* Not yet decided. */
13008 eoltype
= eol_mnemonic_undecided
;
13009 else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
13010 eoltype
= (XFASTINT (eolvalue
) == 0
13011 ? eol_mnemonic_unix
13012 : (XFASTINT (eolvalue
) == 1
13013 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
13019 /* Mention the EOL conversion if it is not the usual one. */
13020 if (STRINGP (eoltype
))
13022 eol_str
= XSTRING (eoltype
)->data
;
13023 eol_str_len
= XSTRING (eoltype
)->size
;
13025 else if (INTEGERP (eoltype
)
13026 && CHAR_VALID_P (XINT (eoltype
), 0))
13028 eol_str
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
);
13029 eol_str_len
= CHAR_STRING (XINT (eoltype
), eol_str
);
13033 eol_str
= invalid_eol_type
;
13034 eol_str_len
= sizeof (invalid_eol_type
) - 1;
13036 bcopy (eol_str
, buf
, eol_str_len
);
13037 buf
+= eol_str_len
;
13043 /* Return a string for the output of a mode line %-spec for window W,
13044 generated by character C. PRECISION >= 0 means don't return a
13045 string longer than that value. FIELD_WIDTH > 0 means pad the
13046 string returned with spaces to that value. */
13048 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
13051 decode_mode_spec (w
, c
, field_width
, precision
)
13054 int field_width
, precision
;
13057 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
13058 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
13059 struct buffer
*b
= XBUFFER (w
->buffer
);
13066 if (!NILP (b
->read_only
))
13068 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
13073 /* This differs from %* only for a modified read-only buffer. */
13074 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
13076 if (!NILP (b
->read_only
))
13081 /* This differs from %* in ignoring read-only-ness. */
13082 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
13094 if (command_loop_level
> 5)
13096 p
= decode_mode_spec_buf
;
13097 for (i
= 0; i
< command_loop_level
; i
++)
13100 return decode_mode_spec_buf
;
13108 if (command_loop_level
> 5)
13110 p
= decode_mode_spec_buf
;
13111 for (i
= 0; i
< command_loop_level
; i
++)
13114 return decode_mode_spec_buf
;
13121 /* Let lots_of_dashes be a string of infinite length. */
13122 if (field_width
<= 0
13123 || field_width
> sizeof (lots_of_dashes
))
13125 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
13126 decode_mode_spec_buf
[i
] = '-';
13127 decode_mode_spec_buf
[i
] = '\0';
13128 return decode_mode_spec_buf
;
13131 return lots_of_dashes
;
13140 int col
= current_column ();
13141 XSETFASTINT (w
->column_number_displayed
, col
);
13142 pint2str (decode_mode_spec_buf
, field_width
, col
);
13143 return decode_mode_spec_buf
;
13147 /* %F displays the frame name. */
13148 if (!NILP (f
->title
))
13149 return (char *) XSTRING (f
->title
)->data
;
13150 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
13151 return (char *) XSTRING (f
->name
)->data
;
13160 int startpos
= XMARKER (w
->start
)->charpos
;
13161 int startpos_byte
= marker_byte_position (w
->start
);
13162 int line
, linepos
, linepos_byte
, topline
;
13164 int height
= XFASTINT (w
->height
);
13166 /* If we decided that this buffer isn't suitable for line numbers,
13167 don't forget that too fast. */
13168 if (EQ (w
->base_line_pos
, w
->buffer
))
13170 /* But do forget it, if the window shows a different buffer now. */
13171 else if (BUFFERP (w
->base_line_pos
))
13172 w
->base_line_pos
= Qnil
;
13174 /* If the buffer is very big, don't waste time. */
13175 if (INTEGERP (Vline_number_display_limit
)
13176 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
13178 w
->base_line_pos
= Qnil
;
13179 w
->base_line_number
= Qnil
;
13183 if (!NILP (w
->base_line_number
)
13184 && !NILP (w
->base_line_pos
)
13185 && XFASTINT (w
->base_line_pos
) <= startpos
)
13187 line
= XFASTINT (w
->base_line_number
);
13188 linepos
= XFASTINT (w
->base_line_pos
);
13189 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
13194 linepos
= BUF_BEGV (b
);
13195 linepos_byte
= BUF_BEGV_BYTE (b
);
13198 /* Count lines from base line to window start position. */
13199 nlines
= display_count_lines (linepos
, linepos_byte
,
13203 topline
= nlines
+ line
;
13205 /* Determine a new base line, if the old one is too close
13206 or too far away, or if we did not have one.
13207 "Too close" means it's plausible a scroll-down would
13208 go back past it. */
13209 if (startpos
== BUF_BEGV (b
))
13211 XSETFASTINT (w
->base_line_number
, topline
);
13212 XSETFASTINT (w
->base_line_pos
, BUF_BEGV (b
));
13214 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
13215 || linepos
== BUF_BEGV (b
))
13217 int limit
= BUF_BEGV (b
);
13218 int limit_byte
= BUF_BEGV_BYTE (b
);
13220 int distance
= (height
* 2 + 30) * line_number_display_limit_width
;
13222 if (startpos
- distance
> limit
)
13224 limit
= startpos
- distance
;
13225 limit_byte
= CHAR_TO_BYTE (limit
);
13228 nlines
= display_count_lines (startpos
, startpos_byte
,
13230 - (height
* 2 + 30),
13232 /* If we couldn't find the lines we wanted within
13233 line_number_display_limit_width chars per line,
13234 give up on line numbers for this window. */
13235 if (position
== limit_byte
&& limit
== startpos
- distance
)
13237 w
->base_line_pos
= w
->buffer
;
13238 w
->base_line_number
= Qnil
;
13242 XSETFASTINT (w
->base_line_number
, topline
- nlines
);
13243 XSETFASTINT (w
->base_line_pos
, BYTE_TO_CHAR (position
));
13246 /* Now count lines from the start pos to point. */
13247 nlines
= display_count_lines (startpos
, startpos_byte
,
13248 PT_BYTE
, PT
, &junk
);
13250 /* Record that we did display the line number. */
13251 line_number_displayed
= 1;
13253 /* Make the string to show. */
13254 pint2str (decode_mode_spec_buf
, field_width
, topline
+ nlines
);
13255 return decode_mode_spec_buf
;
13258 char* p
= decode_mode_spec_buf
;
13259 int pad
= field_width
- 2;
13265 return decode_mode_spec_buf
;
13271 obj
= b
->mode_name
;
13275 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
13281 int pos
= marker_position (w
->start
);
13282 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
13284 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
13286 if (pos
<= BUF_BEGV (b
))
13291 else if (pos
<= BUF_BEGV (b
))
13295 if (total
> 1000000)
13296 /* Do it differently for a large value, to avoid overflow. */
13297 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
13299 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
13300 /* We can't normally display a 3-digit number,
13301 so get us a 2-digit number that is close. */
13304 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
13305 return decode_mode_spec_buf
;
13309 /* Display percentage of size above the bottom of the screen. */
13312 int toppos
= marker_position (w
->start
);
13313 int botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
13314 int total
= BUF_ZV (b
) - BUF_BEGV (b
);
13316 if (botpos
>= BUF_ZV (b
))
13318 if (toppos
<= BUF_BEGV (b
))
13325 if (total
> 1000000)
13326 /* Do it differently for a large value, to avoid overflow. */
13327 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
13329 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
13330 /* We can't normally display a 3-digit number,
13331 so get us a 2-digit number that is close. */
13334 if (toppos
<= BUF_BEGV (b
))
13335 sprintf (decode_mode_spec_buf
, "Top%2d%%", total
);
13337 sprintf (decode_mode_spec_buf
, "%2d%%", total
);
13338 return decode_mode_spec_buf
;
13343 /* status of process */
13344 obj
= Fget_buffer_process (w
->buffer
);
13346 return "no process";
13347 #ifdef subprocesses
13348 obj
= Fsymbol_name (Fprocess_status (obj
));
13352 case 't': /* indicate TEXT or BINARY */
13353 #ifdef MODE_LINE_BINARY_TEXT
13354 return MODE_LINE_BINARY_TEXT (b
);
13360 /* coding-system (not including end-of-line format) */
13362 /* coding-system (including end-of-line type) */
13364 int eol_flag
= (c
== 'Z');
13365 char *p
= decode_mode_spec_buf
;
13367 if (! FRAME_WINDOW_P (f
))
13369 /* No need to mention EOL here--the terminal never needs
13370 to do EOL conversion. */
13371 p
= decode_mode_spec_coding (keyboard_coding
.symbol
, p
, 0);
13372 p
= decode_mode_spec_coding (terminal_coding
.symbol
, p
, 0);
13374 p
= decode_mode_spec_coding (b
->buffer_file_coding_system
,
13377 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
13378 #ifdef subprocesses
13379 obj
= Fget_buffer_process (Fcurrent_buffer ());
13380 if (PROCESSP (obj
))
13382 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
13384 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
13387 #endif /* subprocesses */
13390 return decode_mode_spec_buf
;
13395 return (char *) XSTRING (obj
)->data
;
13401 /* Count up to COUNT lines starting from START / START_BYTE.
13402 But don't go beyond LIMIT_BYTE.
13403 Return the number of lines thus found (always nonnegative).
13405 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
13408 display_count_lines (start
, start_byte
, limit_byte
, count
, byte_pos_ptr
)
13409 int start
, start_byte
, limit_byte
, count
;
13412 register unsigned char *cursor
;
13413 unsigned char *base
;
13415 register int ceiling
;
13416 register unsigned char *ceiling_addr
;
13417 int orig_count
= count
;
13419 /* If we are not in selective display mode,
13420 check only for newlines. */
13421 int selective_display
= (!NILP (current_buffer
->selective_display
)
13422 && !INTEGERP (current_buffer
->selective_display
));
13426 while (start_byte
< limit_byte
)
13428 ceiling
= BUFFER_CEILING_OF (start_byte
);
13429 ceiling
= min (limit_byte
- 1, ceiling
);
13430 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
13431 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
13434 if (selective_display
)
13435 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
13438 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
13441 if (cursor
!= ceiling_addr
)
13445 start_byte
+= cursor
- base
+ 1;
13446 *byte_pos_ptr
= start_byte
;
13450 if (++cursor
== ceiling_addr
)
13456 start_byte
+= cursor
- base
;
13461 while (start_byte
> limit_byte
)
13463 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
13464 ceiling
= max (limit_byte
, ceiling
);
13465 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
13466 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
13469 if (selective_display
)
13470 while (--cursor
!= ceiling_addr
13471 && *cursor
!= '\n' && *cursor
!= 015)
13474 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
13477 if (cursor
!= ceiling_addr
)
13481 start_byte
+= cursor
- base
+ 1;
13482 *byte_pos_ptr
= start_byte
;
13483 /* When scanning backwards, we should
13484 not count the newline posterior to which we stop. */
13485 return - orig_count
- 1;
13491 /* Here we add 1 to compensate for the last decrement
13492 of CURSOR, which took it past the valid range. */
13493 start_byte
+= cursor
- base
+ 1;
13497 *byte_pos_ptr
= limit_byte
;
13500 return - orig_count
+ count
;
13501 return orig_count
- count
;
13507 /***********************************************************************
13509 ***********************************************************************/
13511 /* Display a NUL-terminated string, starting with index START.
13513 If STRING is non-null, display that C string. Otherwise, the Lisp
13514 string LISP_STRING is displayed.
13516 If FACE_STRING is not nil, FACE_STRING_POS is a position in
13517 FACE_STRING. Display STRING or LISP_STRING with the face at
13518 FACE_STRING_POS in FACE_STRING:
13520 Display the string in the environment given by IT, but use the
13521 standard display table, temporarily.
13523 FIELD_WIDTH is the minimum number of output glyphs to produce.
13524 If STRING has fewer characters than FIELD_WIDTH, pad to the right
13525 with spaces. If STRING has more characters, more than FIELD_WIDTH
13526 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
13528 PRECISION is the maximum number of characters to output from
13529 STRING. PRECISION < 0 means don't truncate the string.
13531 This is roughly equivalent to printf format specifiers:
13533 FIELD_WIDTH PRECISION PRINTF
13534 ----------------------------------------
13540 MULTIBYTE zero means do not display multibyte chars, > 0 means do
13541 display them, and < 0 means obey the current buffer's value of
13542 enable_multibyte_characters.
13544 Value is the number of glyphs produced. */
13547 display_string (string
, lisp_string
, face_string
, face_string_pos
,
13548 start
, it
, field_width
, precision
, max_x
, multibyte
)
13549 unsigned char *string
;
13550 Lisp_Object lisp_string
;
13551 Lisp_Object face_string
;
13552 int face_string_pos
;
13555 int field_width
, precision
, max_x
;
13558 int hpos_at_start
= it
->hpos
;
13559 int saved_face_id
= it
->face_id
;
13560 struct glyph_row
*row
= it
->glyph_row
;
13562 /* Initialize the iterator IT for iteration over STRING beginning
13563 with index START. We assume that IT may be modified here (which
13564 means that display_line has to do something when displaying a
13565 mini-buffer prompt, which it does). */
13566 reseat_to_string (it
, string
, lisp_string
, start
,
13567 precision
, field_width
, multibyte
);
13569 /* If displaying STRING, set up the face of the iterator
13570 from LISP_STRING, if that's given. */
13571 if (STRINGP (face_string
))
13577 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
13578 0, it
->region_beg_charpos
,
13579 it
->region_end_charpos
,
13580 &endptr
, it
->base_face_id
);
13581 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
13582 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
13585 /* Set max_x to the maximum allowed X position. Don't let it go
13586 beyond the right edge of the window. */
13588 max_x
= it
->last_visible_x
;
13590 max_x
= min (max_x
, it
->last_visible_x
);
13592 /* Skip over display elements that are not visible. because IT->w is
13594 if (it
->current_x
< it
->first_visible_x
)
13595 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
13596 MOVE_TO_POS
| MOVE_TO_X
);
13598 row
->ascent
= it
->max_ascent
;
13599 row
->height
= it
->max_ascent
+ it
->max_descent
;
13600 row
->phys_ascent
= it
->max_phys_ascent
;
13601 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
13603 /* This condition is for the case that we are called with current_x
13604 past last_visible_x. */
13605 while (it
->current_x
< max_x
)
13607 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
13609 /* Get the next display element. */
13610 if (!get_next_display_element (it
))
13613 /* Produce glyphs. */
13614 x_before
= it
->current_x
;
13615 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
13616 PRODUCE_GLYPHS (it
);
13618 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
13621 while (i
< nglyphs
)
13623 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
13625 if (!it
->truncate_lines_p
13626 && x
+ glyph
->pixel_width
> max_x
)
13628 /* End of continued line or max_x reached. */
13629 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
13633 else if (x
+ glyph
->pixel_width
> it
->first_visible_x
)
13635 /* Glyph is at least partially visible. */
13637 if (x
< it
->first_visible_x
)
13638 it
->glyph_row
->x
= x
- it
->first_visible_x
;
13642 /* Glyph is off the left margin of the display area.
13643 Should not happen. */
13647 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
13648 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
13649 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
13650 row
->phys_height
= max (row
->phys_height
,
13651 it
->max_phys_ascent
+ it
->max_phys_descent
);
13652 x
+= glyph
->pixel_width
;
13656 /* Stop if max_x reached. */
13660 /* Stop at line ends. */
13661 if (ITERATOR_AT_END_OF_LINE_P (it
))
13663 it
->continuation_lines_width
= 0;
13667 set_iterator_to_next (it
, 1);
13669 /* Stop if truncating at the right edge. */
13670 if (it
->truncate_lines_p
13671 && it
->current_x
>= it
->last_visible_x
)
13673 /* Add truncation mark, but don't do it if the line is
13674 truncated at a padding space. */
13675 if (IT_CHARPOS (*it
) < it
->string_nchars
)
13677 if (!FRAME_WINDOW_P (it
->f
))
13678 produce_special_glyphs (it
, IT_TRUNCATION
);
13679 it
->glyph_row
->truncated_on_right_p
= 1;
13685 /* Maybe insert a truncation at the left. */
13686 if (it
->first_visible_x
13687 && IT_CHARPOS (*it
) > 0)
13689 if (!FRAME_WINDOW_P (it
->f
))
13690 insert_left_trunc_glyphs (it
);
13691 it
->glyph_row
->truncated_on_left_p
= 1;
13694 it
->face_id
= saved_face_id
;
13696 /* Value is number of columns displayed. */
13697 return it
->hpos
- hpos_at_start
;
13702 /* This is like a combination of memq and assq. Return 1 if PROPVAL
13703 appears as an element of LIST or as the car of an element of LIST.
13704 If PROPVAL is a list, compare each element against LIST in that
13705 way, and return 1 if any element of PROPVAL is found in LIST.
13706 Otherwise return 0. This function cannot quit. */
13709 invisible_p (propval
, list
)
13710 register Lisp_Object propval
;
13713 register Lisp_Object tail
, proptail
;
13715 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
13717 register Lisp_Object tem
;
13719 if (EQ (propval
, tem
))
13721 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
13725 if (CONSP (propval
))
13727 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
13729 Lisp_Object propelt
;
13730 propelt
= XCAR (proptail
);
13731 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
13733 register Lisp_Object tem
;
13735 if (EQ (propelt
, tem
))
13737 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
13747 /* Return 1 if PROPVAL appears as the car of an element of LIST and
13748 the cdr of that element is non-nil. If PROPVAL is a list, check
13749 each element of PROPVAL in that way, and the first time some
13750 element is found, return 1 if the cdr of that element is non-nil.
13751 Otherwise return 0. This function cannot quit. */
13754 invisible_ellipsis_p (propval
, list
)
13755 register Lisp_Object propval
;
13758 register Lisp_Object tail
, proptail
;
13760 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
13762 register Lisp_Object tem
;
13764 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
13765 return ! NILP (XCDR (tem
));
13768 if (CONSP (propval
))
13769 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
13771 Lisp_Object propelt
;
13772 propelt
= XCAR (proptail
);
13773 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
13775 register Lisp_Object tem
;
13777 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
13778 return ! NILP (XCDR (tem
));
13787 /***********************************************************************
13789 ***********************************************************************/
13794 Vwith_echo_area_save_vector
= Qnil
;
13795 staticpro (&Vwith_echo_area_save_vector
);
13797 Vmessage_stack
= Qnil
;
13798 staticpro (&Vmessage_stack
);
13800 Qinhibit_redisplay
= intern ("inhibit-redisplay");
13801 staticpro (&Qinhibit_redisplay
);
13804 defsubr (&Sdump_glyph_matrix
);
13805 defsubr (&Sdump_glyph_row
);
13806 defsubr (&Sdump_tool_bar_row
);
13807 defsubr (&Strace_redisplay_toggle
);
13808 defsubr (&Strace_to_stderr
);
13811 staticpro (&Qmenu_bar_update_hook
);
13812 Qmenu_bar_update_hook
= intern ("menu-bar-update-hook");
13814 staticpro (&Qoverriding_terminal_local_map
);
13815 Qoverriding_terminal_local_map
= intern ("overriding-terminal-local-map");
13817 staticpro (&Qoverriding_local_map
);
13818 Qoverriding_local_map
= intern ("overriding-local-map");
13820 staticpro (&Qwindow_scroll_functions
);
13821 Qwindow_scroll_functions
= intern ("window-scroll-functions");
13823 staticpro (&Qredisplay_end_trigger_functions
);
13824 Qredisplay_end_trigger_functions
= intern ("redisplay-end-trigger-functions");
13826 staticpro (&Qinhibit_point_motion_hooks
);
13827 Qinhibit_point_motion_hooks
= intern ("inhibit-point-motion-hooks");
13829 QCdata
= intern (":data");
13830 staticpro (&QCdata
);
13831 Qdisplay
= intern ("display");
13832 staticpro (&Qdisplay
);
13833 Qspace_width
= intern ("space-width");
13834 staticpro (&Qspace_width
);
13835 Qraise
= intern ("raise");
13836 staticpro (&Qraise
);
13837 Qspace
= intern ("space");
13838 staticpro (&Qspace
);
13839 Qmargin
= intern ("margin");
13840 staticpro (&Qmargin
);
13841 Qleft_margin
= intern ("left-margin");
13842 staticpro (&Qleft_margin
);
13843 Qright_margin
= intern ("right-margin");
13844 staticpro (&Qright_margin
);
13845 Qalign_to
= intern ("align-to");
13846 staticpro (&Qalign_to
);
13847 QCalign_to
= intern (":align-to");
13848 staticpro (&QCalign_to
);
13849 Qrelative_width
= intern ("relative-width");
13850 staticpro (&Qrelative_width
);
13851 QCrelative_width
= intern (":relative-width");
13852 staticpro (&QCrelative_width
);
13853 QCrelative_height
= intern (":relative-height");
13854 staticpro (&QCrelative_height
);
13855 QCeval
= intern (":eval");
13856 staticpro (&QCeval
);
13857 Qwhen
= intern ("when");
13858 staticpro (&Qwhen
);
13859 QCfile
= intern (":file");
13860 staticpro (&QCfile
);
13861 Qfontified
= intern ("fontified");
13862 staticpro (&Qfontified
);
13863 Qfontification_functions
= intern ("fontification-functions");
13864 staticpro (&Qfontification_functions
);
13865 Qtrailing_whitespace
= intern ("trailing-whitespace");
13866 staticpro (&Qtrailing_whitespace
);
13867 Qimage
= intern ("image");
13868 staticpro (&Qimage
);
13869 Qmessage_truncate_lines
= intern ("message-truncate-lines");
13870 staticpro (&Qmessage_truncate_lines
);
13871 Qgrow_only
= intern ("grow-only");
13872 staticpro (&Qgrow_only
);
13874 last_arrow_position
= Qnil
;
13875 last_arrow_string
= Qnil
;
13876 staticpro (&last_arrow_position
);
13877 staticpro (&last_arrow_string
);
13879 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
13880 staticpro (&echo_buffer
[0]);
13881 staticpro (&echo_buffer
[1]);
13883 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
13884 staticpro (&echo_area_buffer
[0]);
13885 staticpro (&echo_area_buffer
[1]);
13887 Vmessages_buffer_name
= build_string ("*Messages*");
13888 staticpro (&Vmessages_buffer_name
);
13890 DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace
,
13891 "Non-nil means highlight trailing whitespace.\n\
13892 The face used for trailing whitespace is `trailing-whitespace'.");
13893 Vshow_trailing_whitespace
= Qnil
;
13895 DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay
,
13896 "Non-nil means don't actually do any redisplay.\n\
13897 This is used for internal purposes.");
13898 Vinhibit_redisplay
= Qnil
;
13900 DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string
,
13901 "String (or mode line construct) included (normally) in `mode-line-format'.");
13902 Vglobal_mode_string
= Qnil
;
13904 DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position
,
13905 "Marker for where to display an arrow on top of the buffer text.\n\
13906 This must be the beginning of a line in order to work.\n\
13907 See also `overlay-arrow-string'.");
13908 Voverlay_arrow_position
= Qnil
;
13910 DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string
,
13911 "String to display as an arrow. See also `overlay-arrow-position'.");
13912 Voverlay_arrow_string
= Qnil
;
13914 DEFVAR_INT ("scroll-step", &scroll_step
,
13915 "*The number of lines to try scrolling a window by when point moves out.\n\
13916 If that fails to bring point back on frame, point is centered instead.\n\
13917 If this is zero, point is always centered after it moves off frame.\n\
13918 If you want scrolling to always be a line at a time, you should set\n\
13919 `scroll-conservatively' to a large value rather than set this to 1.");
13921 DEFVAR_INT ("scroll-conservatively", &scroll_conservatively
,
13922 "*Scroll up to this many lines, to bring point back on screen.\n\
13923 A value of zero means to scroll the text to center point vertically\n\
13925 scroll_conservatively
= 0;
13927 DEFVAR_INT ("scroll-margin", &scroll_margin
,
13928 "*Number of lines of margin at the top and bottom of a window.\n\
13929 Recenter the window whenever point gets within this many lines\n\
13930 of the top or bottom of the window.");
13934 DEFVAR_INT ("debug-end-pos", &debug_end_pos
, "Don't ask");
13937 DEFVAR_BOOL ("truncate-partial-width-windows",
13938 &truncate_partial_width_windows
,
13939 "*Non-nil means truncate lines in all windows less than full frame wide.");
13940 truncate_partial_width_windows
= 1;
13942 DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video
,
13943 "nil means display the mode-line/header-line/menu-bar in the default face.\n\
13944 Any other value means to use the appropriate face, `mode-line',\n\
13945 `header-line', or `menu' respectively.\n\
13947 This variable is deprecated; please change the above faces instead.");
13948 mode_line_inverse_video
= 1;
13950 DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit
,
13951 "*Maximum buffer size for which line number should be displayed.\n\
13952 If the buffer is bigger than this, the line number does not appear\n\
13953 in the mode line. A value of nil means no limit.");
13954 Vline_number_display_limit
= Qnil
;
13956 DEFVAR_INT ("line-number-display-limit-width",
13957 &line_number_display_limit_width
,
13958 "*Maximum line width (in characters) for line number display.\n\
13959 If the average length of the lines near point is bigger than this, then the\n\
13960 line number may be omitted from the mode line.");
13961 line_number_display_limit_width
= 200;
13963 DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows
,
13964 "*Non-nil means highlight region even in nonselected windows.");
13965 highlight_nonselected_windows
= 0;
13967 DEFVAR_BOOL ("multiple-frames", &multiple_frames
,
13968 "Non-nil if more than one frame is visible on this display.\n\
13969 Minibuffer-only frames don't count, but iconified frames do.\n\
13970 This variable is not guaranteed to be accurate except while processing\n\
13971 `frame-title-format' and `icon-title-format'.");
13973 DEFVAR_LISP ("frame-title-format", &Vframe_title_format
,
13974 "Template for displaying the title bar of visible frames.\n\
13975 \(Assuming the window manager supports this feature.)\n\
13976 This variable has the same structure as `mode-line-format' (which see),\n\
13977 and is used only on frames for which no explicit name has been set\n\
13978 \(see `modify-frame-parameters').");
13979 DEFVAR_LISP ("icon-title-format", &Vicon_title_format
,
13980 "Template for displaying the title bar of an iconified frame.\n\
13981 \(Assuming the window manager supports this feature.)\n\
13982 This variable has the same structure as `mode-line-format' (which see),\n\
13983 and is used only on frames for which no explicit name has been set\n\
13984 \(see `modify-frame-parameters').");
13986 = Vframe_title_format
13987 = Fcons (intern ("multiple-frames"),
13988 Fcons (build_string ("%b"),
13989 Fcons (Fcons (build_string (""),
13990 Fcons (intern ("invocation-name"),
13991 Fcons (build_string ("@"),
13992 Fcons (intern ("system-name"),
13996 DEFVAR_LISP ("message-log-max", &Vmessage_log_max
,
13997 "Maximum number of lines to keep in the message log buffer.\n\
13998 If nil, disable message logging. If t, log messages but don't truncate\n\
13999 the buffer when it becomes large.");
14000 XSETFASTINT (Vmessage_log_max
, 50);
14002 DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions
,
14003 "Functions called before redisplay, if window sizes have changed.\n\
14004 The value should be a list of functions that take one argument.\n\
14005 Just before redisplay, for each frame, if any of its windows have changed\n\
14006 size since the last redisplay, or have been split or deleted,\n\
14007 all the functions in the list are called, with the frame as argument.");
14008 Vwindow_size_change_functions
= Qnil
;
14010 DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions
,
14011 "List of Functions to call before redisplaying a window with scrolling.\n\
14012 Each function is called with two arguments, the window\n\
14013 and its new display-start position. Note that the value of `window-end'\n\
14014 is not valid when these functions are called.");
14015 Vwindow_scroll_functions
= Qnil
;
14017 DEFVAR_BOOL ("auto-resize-tool-bars", &auto_resize_tool_bars_p
,
14018 "*Non-nil means automatically resize tool-bars.\n\
14019 This increases a tool-bar's height if not all tool-bar items are visible.\n\
14020 It decreases a tool-bar's height when it would display blank lines\n\
14022 auto_resize_tool_bars_p
= 1;
14024 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p
,
14025 "*Non-nil means raise tool-bar buttons when the mouse moves over them.");
14026 auto_raise_tool_bar_buttons_p
= 1;
14028 DEFVAR_INT ("tool-bar-button-margin", &tool_bar_button_margin
,
14029 "*Margin around tool-bar buttons in pixels.");
14030 tool_bar_button_margin
= 1;
14032 DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief
,
14033 "Relief thickness of tool-bar buttons.");
14034 tool_bar_button_relief
= 3;
14036 DEFVAR_LISP ("fontification-functions", &Vfontification_functions
,
14037 "List of functions to call to fontify regions of text.\n\
14038 Each function is called with one argument POS. Functions must\n\
14039 fontify a region starting at POS in the current buffer, and give\n\
14040 fontified regions the property `fontified'.\n\
14041 This variable automatically becomes buffer-local when set.");
14042 Vfontification_functions
= Qnil
;
14043 Fmake_variable_buffer_local (Qfontification_functions
);
14045 DEFVAR_BOOL ("unibyte-display-via-language-environment",
14046 &unibyte_display_via_language_environment
,
14047 "*Non-nil means display unibyte text according to language environment.\n\
14048 Specifically this means that unibyte non-ASCII characters\n\
14049 are displayed by converting them to the equivalent multibyte characters\n\
14050 according to the current language environment. As a result, they are\n\
14051 displayed according to the current fontset.");
14052 unibyte_display_via_language_environment
= 0;
14054 DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height
,
14055 "*Maximum height for resizing mini-windows.\n\
14056 If a float, it specifies a fraction of the mini-window frame's height.\n\
14057 If an integer, it specifies a number of lines.");
14058 Vmax_mini_window_height
= make_float (0.25);
14060 DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows
,
14061 "*How to resize mini-windows.\n\
14062 A value of nil means don't automatically resize mini-windows.\n\
14063 A value of t means resize them to fit the text displayed in them.\n\
14064 A value of `grow-only', the default, means let mini-windows grow\n\
14065 only, until their display becomes empty, at which point the windows\n\
14066 go back to their normal size.");
14067 Vresize_mini_windows
= Qgrow_only
;
14069 DEFVAR_BOOL ("cursor-in-non-selected-windows",
14070 &cursor_in_non_selected_windows
,
14071 "*Non-nil means display a hollow cursor in non-selected windows.\n\
14072 Nil means don't display a cursor there.");
14073 cursor_in_non_selected_windows
= 1;
14075 DEFVAR_BOOL ("automatic-hscrolling", &automatic_hscrolling_p
,
14076 "*Non-nil means scroll the display automatically to make point visible.");
14077 automatic_hscrolling_p
= 1;
14079 DEFVAR_LISP ("image-types", &Vimage_types
,
14080 "List of supported image types.\n\
14081 Each element of the list is a symbol for a supported image type.");
14082 Vimage_types
= Qnil
;
14084 DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines
,
14085 "If non-nil, messages are truncated instead of resizing the echo area.\n\
14086 Bind this around calls to `message' to let it take effect.");
14087 message_truncate_lines
= 0;
14089 DEFVAR_LISP ("menu-bar-update-hook", &Vmenu_bar_update_hook
,
14090 "Normal hook run for clicks on menu bar, before displaying a submenu.\n\
14091 Can be used to update submenus whose contents should vary.");
14092 Vmenu_bar_update_hook
= Qnil
;
14096 /* Initialize this module when Emacs starts. */
14101 Lisp_Object root_window
;
14102 struct window
*mini_w
;
14104 current_header_line_height
= current_mode_line_height
= -1;
14106 CHARPOS (this_line_start_pos
) = 0;
14108 mini_w
= XWINDOW (minibuf_window
);
14109 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
14111 if (!noninteractive
)
14113 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
14116 XSETFASTINT (XWINDOW (root_window
)->top
, FRAME_TOP_MARGIN (f
));
14117 set_window_height (root_window
,
14118 FRAME_HEIGHT (f
) - 1 - FRAME_TOP_MARGIN (f
),
14120 XSETFASTINT (mini_w
->top
, FRAME_HEIGHT (f
) - 1);
14121 set_window_height (minibuf_window
, 1, 0);
14123 XSETFASTINT (XWINDOW (root_window
)->width
, FRAME_WIDTH (f
));
14124 XSETFASTINT (mini_w
->width
, FRAME_WIDTH (f
));
14126 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
14127 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
14128 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
14130 /* The default ellipsis glyphs `...'. */
14131 for (i
= 0; i
< 3; ++i
)
14132 XSETFASTINT (default_invis_vector
[i
], '.');
14135 #ifdef HAVE_WINDOW_SYSTEM
14137 /* Allocate the buffer for frame titles. */
14139 frame_title_buf
= (char *) xmalloc (size
);
14140 frame_title_buf_end
= frame_title_buf
+ size
;
14141 frame_title_ptr
= NULL
;
14143 #endif /* HAVE_WINDOW_SYSTEM */
14145 help_echo_showing_p
= 0;