1 /* Display generation from window structure and buffer text.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2012 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
24 Emacs separates the task of updating the display from code
25 modifying global state, e.g. buffer text. This way functions
26 operating on buffers don't also have to be concerned with updating
29 Updating the display is triggered by the Lisp interpreter when it
30 decides it's time to do it. This is done either automatically for
31 you as part of the interpreter's command loop or as the result of
32 calling Lisp functions like `sit-for'. The C function `redisplay'
33 in xdisp.c is the only entry into the inner redisplay code.
35 The following diagram shows how redisplay code is invoked. As you
36 can see, Lisp calls redisplay and vice versa. Under window systems
37 like X, some portions of the redisplay code are also called
38 asynchronously during mouse movement or expose events. It is very
39 important that these code parts do NOT use the C library (malloc,
40 free) because many C libraries under Unix are not reentrant. They
41 may also NOT call functions of the Lisp interpreter which could
42 change the interpreter's state. If you don't follow these rules,
43 you will encounter bugs which are very hard to explain.
45 +--------------+ redisplay +----------------+
46 | Lisp machine |---------------->| Redisplay code |<--+
47 +--------------+ (xdisp.c) +----------------+ |
49 +----------------------------------+ |
50 Don't use this path when called |
53 expose_window (asynchronous) |
55 X expose events -----+
57 What does redisplay do? Obviously, it has to figure out somehow what
58 has been changed since the last time the display has been updated,
59 and to make these changes visible. Preferably it would do that in
60 a moderately intelligent way, i.e. fast.
62 Changes in buffer text can be deduced from window and buffer
63 structures, and from some global variables like `beg_unchanged' and
64 `end_unchanged'. The contents of the display are additionally
65 recorded in a `glyph matrix', a two-dimensional matrix of glyph
66 structures. Each row in such a matrix corresponds to a line on the
67 display, and each glyph in a row corresponds to a column displaying
68 a character, an image, or what else. This matrix is called the
69 `current glyph matrix' or `current matrix' in redisplay
72 For buffer parts that have been changed since the last update, a
73 second glyph matrix is constructed, the so called `desired glyph
74 matrix' or short `desired matrix'. Current and desired matrix are
75 then compared to find a cheap way to update the display, e.g. by
76 reusing part of the display by scrolling lines.
78 You will find a lot of redisplay optimizations when you start
79 looking at the innards of redisplay. The overall goal of all these
80 optimizations is to make redisplay fast because it is done
81 frequently. Some of these optimizations are implemented by the
86 This function tries to update the display if the text in the
87 window did not change and did not scroll, only point moved, and
88 it did not move off the displayed portion of the text.
90 . try_window_reusing_current_matrix
92 This function reuses the current matrix of a window when text
93 has not changed, but the window start changed (e.g., due to
98 This function attempts to redisplay a window by reusing parts of
99 its existing display. It finds and reuses the part that was not
100 changed, and redraws the rest.
104 This function performs the full redisplay of a single window
105 assuming that its fonts were not changed and that the cursor
106 will not end up in the scroll margins. (Loading fonts requires
107 re-adjustment of dimensions of glyph matrices, which makes this
108 method impossible to use.)
110 These optimizations are tried in sequence (some can be skipped if
111 it is known that they are not applicable). If none of the
112 optimizations were successful, redisplay calls redisplay_windows,
113 which performs a full redisplay of all windows.
117 Desired matrices are always built per Emacs window. The function
118 `display_line' is the central function to look at if you are
119 interested. It constructs one row in a desired matrix given an
120 iterator structure containing both a buffer position and a
121 description of the environment in which the text is to be
122 displayed. But this is too early, read on.
124 Characters and pixmaps displayed for a range of buffer text depend
125 on various settings of buffers and windows, on overlays and text
126 properties, on display tables, on selective display. The good news
127 is that all this hairy stuff is hidden behind a small set of
128 interface functions taking an iterator structure (struct it)
131 Iteration over things to be displayed is then simple. It is
132 started by initializing an iterator with a call to init_iterator,
133 passing it the buffer position where to start iteration. For
134 iteration over strings, pass -1 as the position to init_iterator,
135 and call reseat_to_string when the string is ready, to initialize
136 the iterator for that string. Thereafter, calls to
137 get_next_display_element fill the iterator structure with relevant
138 information about the next thing to display. Calls to
139 set_iterator_to_next move the iterator to the next thing.
141 Besides this, an iterator also contains information about the
142 display environment in which glyphs for display elements are to be
143 produced. It has fields for the width and height of the display,
144 the information whether long lines are truncated or continued, a
145 current X and Y position, and lots of other stuff you can better
148 Glyphs in a desired matrix are normally constructed in a loop
149 calling get_next_display_element and then PRODUCE_GLYPHS. The call
150 to PRODUCE_GLYPHS will fill the iterator structure with pixel
151 information about the element being displayed and at the same time
152 produce glyphs for it. If the display element fits on the line
153 being displayed, set_iterator_to_next is called next, otherwise the
154 glyphs produced are discarded. The function display_line is the
155 workhorse of filling glyph rows in the desired matrix with glyphs.
156 In addition to producing glyphs, it also handles line truncation
157 and continuation, word wrap, and cursor positioning (for the
158 latter, see also set_cursor_from_row).
162 That just couldn't be all, could it? What about terminal types not
163 supporting operations on sub-windows of the screen? To update the
164 display on such a terminal, window-based glyph matrices are not
165 well suited. To be able to reuse part of the display (scrolling
166 lines up and down), we must instead have a view of the whole
167 screen. This is what `frame matrices' are for. They are a trick.
169 Frames on terminals like above have a glyph pool. Windows on such
170 a frame sub-allocate their glyph memory from their frame's glyph
171 pool. The frame itself is given its own glyph matrices. By
172 coincidence---or maybe something else---rows in window glyph
173 matrices are slices of corresponding rows in frame matrices. Thus
174 writing to window matrices implicitly updates a frame matrix which
175 provides us with the view of the whole screen that we originally
176 wanted to have without having to move many bytes around. To be
177 honest, there is a little bit more done, but not much more. If you
178 plan to extend that code, take a look at dispnew.c. The function
179 build_frame_matrix is a good starting point.
181 Bidirectional display.
183 Bidirectional display adds quite some hair to this already complex
184 design. The good news are that a large portion of that hairy stuff
185 is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
186 reordering engine which is called by set_iterator_to_next and
187 returns the next character to display in the visual order. See
188 commentary on bidi.c for more details. As far as redisplay is
189 concerned, the effect of calling bidi_move_to_visually_next, the
190 main interface of the reordering engine, is that the iterator gets
191 magically placed on the buffer or string position that is to be
192 displayed next. In other words, a linear iteration through the
193 buffer/string is replaced with a non-linear one. All the rest of
194 the redisplay is oblivious to the bidi reordering.
196 Well, almost oblivious---there are still complications, most of
197 them due to the fact that buffer and string positions no longer
198 change monotonously with glyph indices in a glyph row. Moreover,
199 for continued lines, the buffer positions may not even be
200 monotonously changing with vertical positions. Also, accounting
201 for face changes, overlays, etc. becomes more complex because
202 non-linear iteration could potentially skip many positions with
203 changes, and then cross them again on the way back...
205 One other prominent effect of bidirectional display is that some
206 paragraphs of text need to be displayed starting at the right
207 margin of the window---the so-called right-to-left, or R2L
208 paragraphs. R2L paragraphs are displayed with R2L glyph rows,
209 which have their reversed_p flag set. The bidi reordering engine
210 produces characters in such rows starting from the character which
211 should be the rightmost on display. PRODUCE_GLYPHS then reverses
212 the order, when it fills up the glyph row whose reversed_p flag is
213 set, by prepending each new glyph to what is already there, instead
214 of appending it. When the glyph row is complete, the function
215 extend_face_to_end_of_line fills the empty space to the left of the
216 leftmost character with special glyphs, which will display as,
217 well, empty. On text terminals, these special glyphs are simply
218 blank characters. On graphics terminals, there's a single stretch
219 glyph of a suitably computed width. Both the blanks and the
220 stretch glyph are given the face of the background of the line.
221 This way, the terminal-specific back-end can still draw the glyphs
222 left to right, even for R2L lines.
224 Bidirectional display and character compositions
226 Some scripts cannot be displayed by drawing each character
227 individually, because adjacent characters change each other's shape
228 on display. For example, Arabic and Indic scripts belong to this
231 Emacs display supports this by providing "character compositions",
232 most of which is implemented in composite.c. During the buffer
233 scan that delivers characters to PRODUCE_GLYPHS, if the next
234 character to be delivered is a composed character, the iteration
235 calls composition_reseat_it and next_element_from_composition. If
236 they succeed to compose the character with one or more of the
237 following characters, the whole sequence of characters that where
238 composed is recorded in the `struct composition_it' object that is
239 part of the buffer iterator. The composed sequence could produce
240 one or more font glyphs (called "grapheme clusters") on the screen.
241 Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
242 in the direction corresponding to the current bidi scan direction
243 (recorded in the scan_dir member of the `struct bidi_it' object
244 that is part of the buffer iterator). In particular, if the bidi
245 iterator currently scans the buffer backwards, the grapheme
246 clusters are delivered back to front. This reorders the grapheme
247 clusters as appropriate for the current bidi context. Note that
248 this means that the grapheme clusters are always stored in the
249 LGSTRING object (see composite.c) in the logical order.
251 Moving an iterator in bidirectional text
252 without producing glyphs
254 Note one important detail mentioned above: that the bidi reordering
255 engine, driven by the iterator, produces characters in R2L rows
256 starting at the character that will be the rightmost on display.
257 As far as the iterator is concerned, the geometry of such rows is
258 still left to right, i.e. the iterator "thinks" the first character
259 is at the leftmost pixel position. The iterator does not know that
260 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
261 delivers. This is important when functions from the move_it_*
262 family are used to get to certain screen position or to match
263 screen coordinates with buffer coordinates: these functions use the
264 iterator geometry, which is left to right even in R2L paragraphs.
265 This works well with most callers of move_it_*, because they need
266 to get to a specific column, and columns are still numbered in the
267 reading order, i.e. the rightmost character in a R2L paragraph is
268 still column zero. But some callers do not get well with this; a
269 notable example is mouse clicks that need to find the character
270 that corresponds to certain pixel coordinates. See
271 buffer_posn_from_coords in dispnew.c for how this is handled. */
279 #include "keyboard.h"
282 #include "termchar.h"
283 #include "dispextern.h"
284 #include "character.h"
288 #include "commands.h"
292 #include "termhooks.h"
293 #include "termopts.h"
294 #include "intervals.h"
297 #include "region-cache.h"
300 #include "blockinput.h"
302 #ifdef HAVE_X_WINDOWS
317 #ifndef FRAME_X_OUTPUT
318 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
321 #define INFINITY 10000000
323 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
324 Lisp_Object Qwindow_scroll_functions
;
325 static Lisp_Object Qwindow_text_change_functions
;
326 static Lisp_Object Qredisplay_end_trigger_functions
;
327 Lisp_Object Qinhibit_point_motion_hooks
;
328 static Lisp_Object QCeval
, QCpropertize
;
329 Lisp_Object QCfile
, QCdata
;
330 static Lisp_Object Qfontified
;
331 static Lisp_Object Qgrow_only
;
332 static Lisp_Object Qinhibit_eval_during_redisplay
;
333 static Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
334 static Lisp_Object Qright_to_left
, Qleft_to_right
;
337 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
339 /* Pointer shapes. */
340 static Lisp_Object Qarrow
, Qhand
;
343 /* Holds the list (error). */
344 static Lisp_Object list_of_error
;
346 static Lisp_Object Qfontification_functions
;
348 static Lisp_Object Qwrap_prefix
;
349 static Lisp_Object Qline_prefix
;
350 static Lisp_Object Qredisplay_internal
;
352 /* Non-nil means don't actually do any redisplay. */
354 Lisp_Object Qinhibit_redisplay
;
356 /* Names of text properties relevant for redisplay. */
358 Lisp_Object Qdisplay
;
360 Lisp_Object Qspace
, QCalign_to
;
361 static Lisp_Object QCrelative_width
, QCrelative_height
;
362 Lisp_Object Qleft_margin
, Qright_margin
;
363 static Lisp_Object Qspace_width
, Qraise
;
364 static Lisp_Object Qslice
;
366 static Lisp_Object Qmargin
, Qpointer
;
367 static Lisp_Object Qline_height
;
369 /* These setters are used only in this file, so they can be private. */
371 wset_base_line_number (struct window
*w
, Lisp_Object val
)
373 w
->base_line_number
= val
;
376 wset_base_line_pos (struct window
*w
, Lisp_Object val
)
378 w
->base_line_pos
= val
;
381 wset_column_number_displayed (struct window
*w
, Lisp_Object val
)
383 w
->column_number_displayed
= val
;
386 wset_region_showing (struct window
*w
, Lisp_Object val
)
388 w
->region_showing
= val
;
391 #ifdef HAVE_WINDOW_SYSTEM
393 /* Test if overflow newline into fringe. Called with iterator IT
394 at or past right window margin, and with IT->current_x set. */
396 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
397 (!NILP (Voverflow_newline_into_fringe) \
398 && FRAME_WINDOW_P ((IT)->f) \
399 && ((IT)->bidi_it.paragraph_dir == R2L \
400 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
401 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
402 && (IT)->current_x == (IT)->last_visible_x \
403 && (IT)->line_wrap != WORD_WRAP)
405 #else /* !HAVE_WINDOW_SYSTEM */
406 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
407 #endif /* HAVE_WINDOW_SYSTEM */
409 /* Test if the display element loaded in IT, or the underlying buffer
410 or string character, is a space or a TAB character. This is used
411 to determine where word wrapping can occur. */
413 #define IT_DISPLAYING_WHITESPACE(it) \
414 ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t')) \
415 || ((STRINGP (it->string) \
416 && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' ' \
417 || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t')) \
419 && (it->s[IT_BYTEPOS (*it)] == ' ' \
420 || it->s[IT_BYTEPOS (*it)] == '\t')) \
421 || (IT_BYTEPOS (*it) < ZV_BYTE \
422 && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' ' \
423 || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t')))) \
425 /* Name of the face used to highlight trailing whitespace. */
427 static Lisp_Object Qtrailing_whitespace
;
429 /* Name and number of the face used to highlight escape glyphs. */
431 static Lisp_Object Qescape_glyph
;
433 /* Name and number of the face used to highlight non-breaking spaces. */
435 static Lisp_Object Qnobreak_space
;
437 /* The symbol `image' which is the car of the lists used to represent
438 images in Lisp. Also a tool bar style. */
442 /* The image map types. */
444 static Lisp_Object QCpointer
;
445 static Lisp_Object Qrect
, Qcircle
, Qpoly
;
447 /* Tool bar styles */
448 Lisp_Object Qboth
, Qboth_horiz
, Qtext_image_horiz
;
450 /* Non-zero means print newline to stdout before next mini-buffer
453 int noninteractive_need_newline
;
455 /* Non-zero means print newline to message log before next message. */
457 static int message_log_need_newline
;
459 /* Three markers that message_dolog uses.
460 It could allocate them itself, but that causes trouble
461 in handling memory-full errors. */
462 static Lisp_Object message_dolog_marker1
;
463 static Lisp_Object message_dolog_marker2
;
464 static Lisp_Object message_dolog_marker3
;
466 /* The buffer position of the first character appearing entirely or
467 partially on the line of the selected window which contains the
468 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
469 redisplay optimization in redisplay_internal. */
471 static struct text_pos this_line_start_pos
;
473 /* Number of characters past the end of the line above, including the
474 terminating newline. */
476 static struct text_pos this_line_end_pos
;
478 /* The vertical positions and the height of this line. */
480 static int this_line_vpos
;
481 static int this_line_y
;
482 static int this_line_pixel_height
;
484 /* X position at which this display line starts. Usually zero;
485 negative if first character is partially visible. */
487 static int this_line_start_x
;
489 /* The smallest character position seen by move_it_* functions as they
490 move across display lines. Used to set MATRIX_ROW_START_CHARPOS of
491 hscrolled lines, see display_line. */
493 static struct text_pos this_line_min_pos
;
495 /* Buffer that this_line_.* variables are referring to. */
497 static struct buffer
*this_line_buffer
;
500 /* Values of those variables at last redisplay are stored as
501 properties on `overlay-arrow-position' symbol. However, if
502 Voverlay_arrow_position is a marker, last-arrow-position is its
503 numerical position. */
505 static Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
507 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
508 properties on a symbol in overlay-arrow-variable-list. */
510 static Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
512 Lisp_Object Qmenu_bar_update_hook
;
514 /* Nonzero if an overlay arrow has been displayed in this window. */
516 static int overlay_arrow_seen
;
518 /* Number of windows showing the buffer of the selected window (or
519 another buffer with the same base buffer). keyboard.c refers to
524 /* Vector containing glyphs for an ellipsis `...'. */
526 static Lisp_Object default_invis_vector
[3];
528 /* This is the window where the echo area message was displayed. It
529 is always a mini-buffer window, but it may not be the same window
530 currently active as a mini-buffer. */
532 Lisp_Object echo_area_window
;
534 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
535 pushes the current message and the value of
536 message_enable_multibyte on the stack, the function restore_message
537 pops the stack and displays MESSAGE again. */
539 static Lisp_Object Vmessage_stack
;
541 /* Nonzero means multibyte characters were enabled when the echo area
542 message was specified. */
544 static int message_enable_multibyte
;
546 /* Nonzero if we should redraw the mode lines on the next redisplay. */
548 int update_mode_lines
;
550 /* Nonzero if window sizes or contents have changed since last
551 redisplay that finished. */
553 int windows_or_buffers_changed
;
555 /* Nonzero means a frame's cursor type has been changed. */
557 int cursor_type_changed
;
559 /* Nonzero after display_mode_line if %l was used and it displayed a
562 static int line_number_displayed
;
564 /* The name of the *Messages* buffer, a string. */
566 static Lisp_Object Vmessages_buffer_name
;
568 /* Current, index 0, and last displayed echo area message. Either
569 buffers from echo_buffers, or nil to indicate no message. */
571 Lisp_Object echo_area_buffer
[2];
573 /* The buffers referenced from echo_area_buffer. */
575 static Lisp_Object echo_buffer
[2];
577 /* A vector saved used in with_area_buffer to reduce consing. */
579 static Lisp_Object Vwith_echo_area_save_vector
;
581 /* Non-zero means display_echo_area should display the last echo area
582 message again. Set by redisplay_preserve_echo_area. */
584 static int display_last_displayed_message_p
;
586 /* Nonzero if echo area is being used by print; zero if being used by
589 static int message_buf_print
;
591 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
593 static Lisp_Object Qinhibit_menubar_update
;
594 static Lisp_Object Qmessage_truncate_lines
;
596 /* Set to 1 in clear_message to make redisplay_internal aware
597 of an emptied echo area. */
599 static int message_cleared_p
;
601 /* A scratch glyph row with contents used for generating truncation
602 glyphs. Also used in direct_output_for_insert. */
604 #define MAX_SCRATCH_GLYPHS 100
605 static struct glyph_row scratch_glyph_row
;
606 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
608 /* Ascent and height of the last line processed by move_it_to. */
610 static int last_max_ascent
, last_height
;
612 /* Non-zero if there's a help-echo in the echo area. */
614 int help_echo_showing_p
;
616 /* If >= 0, computed, exact values of mode-line and header-line height
617 to use in the macros CURRENT_MODE_LINE_HEIGHT and
618 CURRENT_HEADER_LINE_HEIGHT. */
620 int current_mode_line_height
, current_header_line_height
;
622 /* The maximum distance to look ahead for text properties. Values
623 that are too small let us call compute_char_face and similar
624 functions too often which is expensive. Values that are too large
625 let us call compute_char_face and alike too often because we
626 might not be interested in text properties that far away. */
628 #define TEXT_PROP_DISTANCE_LIMIT 100
630 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
631 iterator state and later restore it. This is needed because the
632 bidi iterator on bidi.c keeps a stacked cache of its states, which
633 is really a singleton. When we use scratch iterator objects to
634 move around the buffer, we can cause the bidi cache to be pushed or
635 popped, and therefore we need to restore the cache state when we
636 return to the original iterator. */
637 #define SAVE_IT(ITCOPY,ITORIG,CACHE) \
640 bidi_unshelve_cache (CACHE, 1); \
642 CACHE = bidi_shelve_cache (); \
645 #define RESTORE_IT(pITORIG,pITCOPY,CACHE) \
647 if (pITORIG != pITCOPY) \
648 *(pITORIG) = *(pITCOPY); \
649 bidi_unshelve_cache (CACHE, 0); \
655 /* Non-zero means print traces of redisplay if compiled with
656 GLYPH_DEBUG defined. */
658 int trace_redisplay_p
;
660 #endif /* GLYPH_DEBUG */
662 #ifdef DEBUG_TRACE_MOVE
663 /* Non-zero means trace with TRACE_MOVE to stderr. */
666 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
668 #define TRACE_MOVE(x) (void) 0
671 static Lisp_Object Qauto_hscroll_mode
;
673 /* Buffer being redisplayed -- for redisplay_window_error. */
675 static struct buffer
*displayed_buffer
;
677 /* Value returned from text property handlers (see below). */
682 HANDLED_RECOMPUTE_PROPS
,
683 HANDLED_OVERLAY_STRING_CONSUMED
,
687 /* A description of text properties that redisplay is interested
692 /* The name of the property. */
695 /* A unique index for the property. */
698 /* A handler function called to set up iterator IT from the property
699 at IT's current position. Value is used to steer handle_stop. */
700 enum prop_handled (*handler
) (struct it
*it
);
703 static enum prop_handled
handle_face_prop (struct it
*);
704 static enum prop_handled
handle_invisible_prop (struct it
*);
705 static enum prop_handled
handle_display_prop (struct it
*);
706 static enum prop_handled
handle_composition_prop (struct it
*);
707 static enum prop_handled
handle_overlay_change (struct it
*);
708 static enum prop_handled
handle_fontified_prop (struct it
*);
710 /* Properties handled by iterators. */
712 static struct props it_props
[] =
714 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
715 /* Handle `face' before `display' because some sub-properties of
716 `display' need to know the face. */
717 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
718 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
719 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
720 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
724 /* Value is the position described by X. If X is a marker, value is
725 the marker_position of X. Otherwise, value is X. */
727 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
729 /* Enumeration returned by some move_it_.* functions internally. */
733 /* Not used. Undefined value. */
736 /* Move ended at the requested buffer position or ZV. */
737 MOVE_POS_MATCH_OR_ZV
,
739 /* Move ended at the requested X pixel position. */
742 /* Move within a line ended at the end of a line that must be
746 /* Move within a line ended at the end of a line that would
747 be displayed truncated. */
750 /* Move within a line ended at a line end. */
754 /* This counter is used to clear the face cache every once in a while
755 in redisplay_internal. It is incremented for each redisplay.
756 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
759 #define CLEAR_FACE_CACHE_COUNT 500
760 static int clear_face_cache_count
;
762 /* Similarly for the image cache. */
764 #ifdef HAVE_WINDOW_SYSTEM
765 #define CLEAR_IMAGE_CACHE_COUNT 101
766 static int clear_image_cache_count
;
768 /* Null glyph slice */
769 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
772 /* True while redisplay_internal is in progress. */
776 static Lisp_Object Qinhibit_free_realized_faces
;
777 static Lisp_Object Qmode_line_default_help_echo
;
779 /* If a string, XTread_socket generates an event to display that string.
780 (The display is done in read_char.) */
782 Lisp_Object help_echo_string
;
783 Lisp_Object help_echo_window
;
784 Lisp_Object help_echo_object
;
785 ptrdiff_t help_echo_pos
;
787 /* Temporary variable for XTread_socket. */
789 Lisp_Object previous_help_echo_string
;
791 /* Platform-independent portion of hourglass implementation. */
793 /* Non-zero means an hourglass cursor is currently shown. */
794 int hourglass_shown_p
;
796 /* If non-null, an asynchronous timer that, when it expires, displays
797 an hourglass cursor on all frames. */
798 struct atimer
*hourglass_atimer
;
800 /* Name of the face used to display glyphless characters. */
801 Lisp_Object Qglyphless_char
;
803 /* Symbol for the purpose of Vglyphless_char_display. */
804 static Lisp_Object Qglyphless_char_display
;
806 /* Method symbols for Vglyphless_char_display. */
807 static Lisp_Object Qhex_code
, Qempty_box
, Qthin_space
, Qzero_width
;
809 /* Default pixel width of `thin-space' display method. */
810 #define THIN_SPACE_WIDTH 1
812 /* Default number of seconds to wait before displaying an hourglass
814 #define DEFAULT_HOURGLASS_DELAY 1
817 /* Function prototypes. */
819 static void setup_for_ellipsis (struct it
*, int);
820 static void set_iterator_to_next (struct it
*, int);
821 static void mark_window_display_accurate_1 (struct window
*, int);
822 static int single_display_spec_string_p (Lisp_Object
, Lisp_Object
);
823 static int display_prop_string_p (Lisp_Object
, Lisp_Object
);
824 static int cursor_row_p (struct glyph_row
*);
825 static int redisplay_mode_lines (Lisp_Object
, int);
826 static char *decode_mode_spec_coding (Lisp_Object
, char *, int);
828 static Lisp_Object
get_it_property (struct it
*it
, Lisp_Object prop
);
830 static void handle_line_prefix (struct it
*);
832 static void pint2str (char *, int, ptrdiff_t);
833 static void pint2hrstr (char *, int, ptrdiff_t);
834 static struct text_pos
run_window_scroll_functions (Lisp_Object
,
836 static void reconsider_clip_changes (struct window
*, struct buffer
*);
837 static int text_outside_line_unchanged_p (struct window
*,
838 ptrdiff_t, ptrdiff_t);
839 static void store_mode_line_noprop_char (char);
840 static int store_mode_line_noprop (const char *, int, int);
841 static void handle_stop (struct it
*);
842 static void handle_stop_backwards (struct it
*, ptrdiff_t);
843 static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
844 static void ensure_echo_area_buffers (void);
845 static Lisp_Object
unwind_with_echo_area_buffer (Lisp_Object
);
846 static Lisp_Object
with_echo_area_buffer_unwind_data (struct window
*);
847 static int with_echo_area_buffer (struct window
*, int,
848 int (*) (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t),
849 ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
850 static void clear_garbaged_frames (void);
851 static int current_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
852 static void pop_message (void);
853 static int truncate_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
854 static void set_message (const char *, Lisp_Object
, ptrdiff_t, int);
855 static int set_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
856 static int display_echo_area (struct window
*);
857 static int display_echo_area_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
858 static int resize_mini_window_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
859 static Lisp_Object
unwind_redisplay (Lisp_Object
);
860 static int string_char_and_length (const unsigned char *, int *);
861 static struct text_pos
display_prop_end (struct it
*, Lisp_Object
,
863 static int compute_window_start_on_continuation_line (struct window
*);
864 static void insert_left_trunc_glyphs (struct it
*);
865 static struct glyph_row
*get_overlay_arrow_glyph_row (struct window
*,
867 static void extend_face_to_end_of_line (struct it
*);
868 static int append_space_for_newline (struct it
*, int);
869 static int cursor_row_fully_visible_p (struct window
*, int, int);
870 static int try_scrolling (Lisp_Object
, int, ptrdiff_t, ptrdiff_t, int, int);
871 static int try_cursor_movement (Lisp_Object
, struct text_pos
, int *);
872 static int trailing_whitespace_p (ptrdiff_t);
873 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
874 static void push_it (struct it
*, struct text_pos
*);
875 static void iterate_out_of_display_property (struct it
*);
876 static void pop_it (struct it
*);
877 static void sync_frame_with_window_matrix_rows (struct window
*);
878 static void select_frame_for_redisplay (Lisp_Object
);
879 static void redisplay_internal (void);
880 static int echo_area_display (int);
881 static void redisplay_windows (Lisp_Object
);
882 static void redisplay_window (Lisp_Object
, int);
883 static Lisp_Object
redisplay_window_error (Lisp_Object
);
884 static Lisp_Object
redisplay_window_0 (Lisp_Object
);
885 static Lisp_Object
redisplay_window_1 (Lisp_Object
);
886 static int set_cursor_from_row (struct window
*, struct glyph_row
*,
887 struct glyph_matrix
*, ptrdiff_t, ptrdiff_t,
889 static int update_menu_bar (struct frame
*, int, int);
890 static int try_window_reusing_current_matrix (struct window
*);
891 static int try_window_id (struct window
*);
892 static int display_line (struct it
*);
893 static int display_mode_lines (struct window
*);
894 static int display_mode_line (struct window
*, enum face_id
, Lisp_Object
);
895 static int display_mode_element (struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int);
896 static int store_mode_line_string (const char *, Lisp_Object
, int, int, int, Lisp_Object
);
897 static const char *decode_mode_spec (struct window
*, int, int, Lisp_Object
*);
898 static void display_menu_bar (struct window
*);
899 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
901 static int display_string (const char *, Lisp_Object
, Lisp_Object
,
902 ptrdiff_t, ptrdiff_t, struct it
*, int, int, int, int);
903 static void compute_line_metrics (struct it
*);
904 static void run_redisplay_end_trigger_hook (struct it
*);
905 static int get_overlay_strings (struct it
*, ptrdiff_t);
906 static int get_overlay_strings_1 (struct it
*, ptrdiff_t, int);
907 static void next_overlay_string (struct it
*);
908 static void reseat (struct it
*, struct text_pos
, int);
909 static void reseat_1 (struct it
*, struct text_pos
, int);
910 static void back_to_previous_visible_line_start (struct it
*);
911 void reseat_at_previous_visible_line_start (struct it
*);
912 static void reseat_at_next_visible_line_start (struct it
*, int);
913 static int next_element_from_ellipsis (struct it
*);
914 static int next_element_from_display_vector (struct it
*);
915 static int next_element_from_string (struct it
*);
916 static int next_element_from_c_string (struct it
*);
917 static int next_element_from_buffer (struct it
*);
918 static int next_element_from_composition (struct it
*);
919 static int next_element_from_image (struct it
*);
920 static int next_element_from_stretch (struct it
*);
921 static void load_overlay_strings (struct it
*, ptrdiff_t);
922 static int init_from_display_pos (struct it
*, struct window
*,
923 struct display_pos
*);
924 static void reseat_to_string (struct it
*, const char *,
925 Lisp_Object
, ptrdiff_t, ptrdiff_t, int, int);
926 static int get_next_display_element (struct it
*);
927 static enum move_it_result
928 move_it_in_display_line_to (struct it
*, ptrdiff_t, int,
929 enum move_operation_enum
);
930 void move_it_vertically_backward (struct it
*, int);
931 static void get_visually_first_element (struct it
*);
932 static void init_to_row_start (struct it
*, struct window
*,
934 static int init_to_row_end (struct it
*, struct window
*,
936 static void back_to_previous_line_start (struct it
*);
937 static int forward_to_next_line_start (struct it
*, int *, struct bidi_it
*);
938 static struct text_pos
string_pos_nchars_ahead (struct text_pos
,
939 Lisp_Object
, ptrdiff_t);
940 static struct text_pos
string_pos (ptrdiff_t, Lisp_Object
);
941 static struct text_pos
c_string_pos (ptrdiff_t, const char *, int);
942 static ptrdiff_t number_of_chars (const char *, int);
943 static void compute_stop_pos (struct it
*);
944 static void compute_string_pos (struct text_pos
*, struct text_pos
,
946 static int face_before_or_after_it_pos (struct it
*, int);
947 static ptrdiff_t next_overlay_change (ptrdiff_t);
948 static int handle_display_spec (struct it
*, Lisp_Object
, Lisp_Object
,
949 Lisp_Object
, struct text_pos
*, ptrdiff_t, int);
950 static int handle_single_display_spec (struct it
*, Lisp_Object
,
951 Lisp_Object
, Lisp_Object
,
952 struct text_pos
*, ptrdiff_t, int, int);
953 static int underlying_face_id (struct it
*);
954 static int in_ellipses_for_invisible_text_p (struct display_pos
*,
957 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
958 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
960 #ifdef HAVE_WINDOW_SYSTEM
962 static void x_consider_frame_title (Lisp_Object
);
963 static int tool_bar_lines_needed (struct frame
*, int *);
964 static void update_tool_bar (struct frame
*, int);
965 static void build_desired_tool_bar_string (struct frame
*f
);
966 static int redisplay_tool_bar (struct frame
*);
967 static void display_tool_bar_line (struct it
*, int);
968 static void notice_overwritten_cursor (struct window
*,
971 static void append_stretch_glyph (struct it
*, Lisp_Object
,
975 #endif /* HAVE_WINDOW_SYSTEM */
977 static void produce_special_glyphs (struct it
*, enum display_element_type
);
978 static void show_mouse_face (Mouse_HLInfo
*, enum draw_glyphs_face
);
979 static int coords_in_mouse_face_p (struct window
*, int, int);
983 /***********************************************************************
984 Window display dimensions
985 ***********************************************************************/
987 /* Return the bottom boundary y-position for text lines in window W.
988 This is the first y position at which a line cannot start.
989 It is relative to the top of the window.
991 This is the height of W minus the height of a mode line, if any. */
994 window_text_bottom_y (struct window
*w
)
996 int height
= WINDOW_TOTAL_HEIGHT (w
);
998 if (WINDOW_WANTS_MODELINE_P (w
))
999 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
1003 /* Return the pixel width of display area AREA of window W. AREA < 0
1004 means return the total width of W, not including fringes to
1005 the left and right of the window. */
1008 window_box_width (struct window
*w
, int area
)
1010 int cols
= XFASTINT (w
->total_cols
);
1013 if (!w
->pseudo_window_p
)
1015 cols
-= WINDOW_SCROLL_BAR_COLS (w
);
1017 if (area
== TEXT_AREA
)
1019 if (INTEGERP (w
->left_margin_cols
))
1020 cols
-= XFASTINT (w
->left_margin_cols
);
1021 if (INTEGERP (w
->right_margin_cols
))
1022 cols
-= XFASTINT (w
->right_margin_cols
);
1023 pixels
= -WINDOW_TOTAL_FRINGE_WIDTH (w
);
1025 else if (area
== LEFT_MARGIN_AREA
)
1027 cols
= (INTEGERP (w
->left_margin_cols
)
1028 ? XFASTINT (w
->left_margin_cols
) : 0);
1031 else if (area
== RIGHT_MARGIN_AREA
)
1033 cols
= (INTEGERP (w
->right_margin_cols
)
1034 ? XFASTINT (w
->right_margin_cols
) : 0);
1039 return cols
* WINDOW_FRAME_COLUMN_WIDTH (w
) + pixels
;
1043 /* Return the pixel height of the display area of window W, not
1044 including mode lines of W, if any. */
1047 window_box_height (struct window
*w
)
1049 struct frame
*f
= XFRAME (w
->frame
);
1050 int height
= WINDOW_TOTAL_HEIGHT (w
);
1052 eassert (height
>= 0);
1054 /* Note: the code below that determines the mode-line/header-line
1055 height is essentially the same as that contained in the macro
1056 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1057 the appropriate glyph row has its `mode_line_p' flag set,
1058 and if it doesn't, uses estimate_mode_line_height instead. */
1060 if (WINDOW_WANTS_MODELINE_P (w
))
1062 struct glyph_row
*ml_row
1063 = (w
->current_matrix
&& w
->current_matrix
->rows
1064 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1066 if (ml_row
&& ml_row
->mode_line_p
)
1067 height
-= ml_row
->height
;
1069 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1072 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1074 struct glyph_row
*hl_row
1075 = (w
->current_matrix
&& w
->current_matrix
->rows
1076 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1078 if (hl_row
&& hl_row
->mode_line_p
)
1079 height
-= hl_row
->height
;
1081 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1084 /* With a very small font and a mode-line that's taller than
1085 default, we might end up with a negative height. */
1086 return max (0, height
);
1089 /* Return the window-relative coordinate of the left edge of display
1090 area AREA of window W. AREA < 0 means return the left edge of the
1091 whole window, to the right of the left fringe of W. */
1094 window_box_left_offset (struct window
*w
, int area
)
1098 if (w
->pseudo_window_p
)
1101 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1103 if (area
== TEXT_AREA
)
1104 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1105 + window_box_width (w
, LEFT_MARGIN_AREA
));
1106 else if (area
== RIGHT_MARGIN_AREA
)
1107 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1108 + window_box_width (w
, LEFT_MARGIN_AREA
)
1109 + window_box_width (w
, TEXT_AREA
)
1110 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1112 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1113 else if (area
== LEFT_MARGIN_AREA
1114 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1115 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1121 /* Return the window-relative coordinate of the right edge of display
1122 area AREA of window W. AREA < 0 means return the right edge of the
1123 whole window, to the left of the right fringe of W. */
1126 window_box_right_offset (struct window
*w
, int area
)
1128 return window_box_left_offset (w
, area
) + window_box_width (w
, area
);
1131 /* Return the frame-relative coordinate of the left edge of display
1132 area AREA of window W. AREA < 0 means return the left edge of the
1133 whole window, to the right of the left fringe of W. */
1136 window_box_left (struct window
*w
, int area
)
1138 struct frame
*f
= XFRAME (w
->frame
);
1141 if (w
->pseudo_window_p
)
1142 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1144 x
= (WINDOW_LEFT_EDGE_X (w
)
1145 + window_box_left_offset (w
, area
));
1151 /* Return the frame-relative coordinate of the right edge of display
1152 area AREA of window W. AREA < 0 means return the right edge of the
1153 whole window, to the left of the right fringe of W. */
1156 window_box_right (struct window
*w
, int area
)
1158 return window_box_left (w
, area
) + window_box_width (w
, area
);
1161 /* Get the bounding box of the display area AREA of window W, without
1162 mode lines, in frame-relative coordinates. AREA < 0 means the
1163 whole window, not including the left and right fringes of
1164 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1165 coordinates of the upper-left corner of the box. Return in
1166 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1169 window_box (struct window
*w
, int area
, int *box_x
, int *box_y
,
1170 int *box_width
, int *box_height
)
1173 *box_width
= window_box_width (w
, area
);
1175 *box_height
= window_box_height (w
);
1177 *box_x
= window_box_left (w
, area
);
1180 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1181 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1182 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1187 /* Get the bounding box of the display area AREA of window W, without
1188 mode lines. AREA < 0 means the whole window, not including the
1189 left and right fringe of the window. Return in *TOP_LEFT_X
1190 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1191 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1192 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1196 window_box_edges (struct window
*w
, int area
, int *top_left_x
, int *top_left_y
,
1197 int *bottom_right_x
, int *bottom_right_y
)
1199 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1201 *bottom_right_x
+= *top_left_x
;
1202 *bottom_right_y
+= *top_left_y
;
1207 /***********************************************************************
1209 ***********************************************************************/
1211 /* Return the bottom y-position of the line the iterator IT is in.
1212 This can modify IT's settings. */
1215 line_bottom_y (struct it
*it
)
1217 int line_height
= it
->max_ascent
+ it
->max_descent
;
1218 int line_top_y
= it
->current_y
;
1220 if (line_height
== 0)
1223 line_height
= last_height
;
1224 else if (IT_CHARPOS (*it
) < ZV
)
1226 move_it_by_lines (it
, 1);
1227 line_height
= (it
->max_ascent
|| it
->max_descent
1228 ? it
->max_ascent
+ it
->max_descent
1233 struct glyph_row
*row
= it
->glyph_row
;
1235 /* Use the default character height. */
1236 it
->glyph_row
= NULL
;
1237 it
->what
= IT_CHARACTER
;
1240 PRODUCE_GLYPHS (it
);
1241 line_height
= it
->ascent
+ it
->descent
;
1242 it
->glyph_row
= row
;
1246 return line_top_y
+ line_height
;
1249 /* Subroutine of pos_visible_p below. Extracts a display string, if
1250 any, from the display spec given as its argument. */
1252 string_from_display_spec (Lisp_Object spec
)
1256 while (CONSP (spec
))
1258 if (STRINGP (XCAR (spec
)))
1263 else if (VECTORP (spec
))
1267 for (i
= 0; i
< ASIZE (spec
); i
++)
1269 if (STRINGP (AREF (spec
, i
)))
1270 return AREF (spec
, i
);
1279 /* Limit insanely large values of W->hscroll on frame F to the largest
1280 value that will still prevent first_visible_x and last_visible_x of
1281 'struct it' from overflowing an int. */
1283 window_hscroll_limited (struct window
*w
, struct frame
*f
)
1285 ptrdiff_t window_hscroll
= w
->hscroll
;
1286 int window_text_width
= window_box_width (w
, TEXT_AREA
);
1287 int colwidth
= FRAME_COLUMN_WIDTH (f
);
1289 if (window_hscroll
> (INT_MAX
- window_text_width
) / colwidth
- 1)
1290 window_hscroll
= (INT_MAX
- window_text_width
) / colwidth
- 1;
1292 return window_hscroll
;
1295 /* Return 1 if position CHARPOS is visible in window W.
1296 CHARPOS < 0 means return info about WINDOW_END position.
1297 If visible, set *X and *Y to pixel coordinates of top left corner.
1298 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1299 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1302 pos_visible_p (struct window
*w
, ptrdiff_t charpos
, int *x
, int *y
,
1303 int *rtop
, int *rbot
, int *rowh
, int *vpos
)
1306 void *itdata
= bidi_shelve_cache ();
1307 struct text_pos top
;
1309 struct buffer
*old_buffer
= NULL
;
1311 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w
))))
1314 if (XBUFFER (w
->buffer
) != current_buffer
)
1316 old_buffer
= current_buffer
;
1317 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1320 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1321 /* Scrolling a minibuffer window via scroll bar when the echo area
1322 shows long text sometimes resets the minibuffer contents behind
1324 if (CHARPOS (top
) > ZV
)
1325 SET_TEXT_POS (top
, BEGV
, BEGV_BYTE
);
1327 /* Compute exact mode line heights. */
1328 if (WINDOW_WANTS_MODELINE_P (w
))
1329 current_mode_line_height
1330 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1331 BVAR (current_buffer
, mode_line_format
));
1333 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1334 current_header_line_height
1335 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1336 BVAR (current_buffer
, header_line_format
));
1338 start_display (&it
, w
, top
);
1339 move_it_to (&it
, charpos
, -1, it
.last_visible_y
-1, -1,
1340 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1343 && (((!it
.bidi_p
|| it
.bidi_it
.scan_dir
== 1)
1344 && IT_CHARPOS (it
) >= charpos
)
1345 /* When scanning backwards under bidi iteration, move_it_to
1346 stops at or _before_ CHARPOS, because it stops at or to
1347 the _right_ of the character at CHARPOS. */
1348 || (it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1349 && IT_CHARPOS (it
) <= charpos
)))
1351 /* We have reached CHARPOS, or passed it. How the call to
1352 move_it_to can overshoot: (i) If CHARPOS is on invisible text
1353 or covered by a display property, move_it_to stops at the end
1354 of the invisible text, to the right of CHARPOS. (ii) If
1355 CHARPOS is in a display vector, move_it_to stops on its last
1357 int top_x
= it
.current_x
;
1358 int top_y
= it
.current_y
;
1359 /* Calling line_bottom_y may change it.method, it.position, etc. */
1360 enum it_method it_method
= it
.method
;
1361 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1362 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1364 if (top_y
< window_top_y
)
1365 visible_p
= bottom_y
> window_top_y
;
1366 else if (top_y
< it
.last_visible_y
)
1368 if (bottom_y
>= it
.last_visible_y
1369 && it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1370 && IT_CHARPOS (it
) < charpos
)
1372 /* When the last line of the window is scanned backwards
1373 under bidi iteration, we could be duped into thinking
1374 that we have passed CHARPOS, when in fact move_it_to
1375 simply stopped short of CHARPOS because it reached
1376 last_visible_y. To see if that's what happened, we call
1377 move_it_to again with a slightly larger vertical limit,
1378 and see if it actually moved vertically; if it did, we
1379 didn't really reach CHARPOS, which is beyond window end. */
1380 struct it save_it
= it
;
1381 /* Why 10? because we don't know how many canonical lines
1382 will the height of the next line(s) be. So we guess. */
1383 int ten_more_lines
=
1384 10 * FRAME_LINE_HEIGHT (XFRAME (WINDOW_FRAME (w
)));
1386 move_it_to (&it
, charpos
, -1, bottom_y
+ ten_more_lines
, -1,
1387 MOVE_TO_POS
| MOVE_TO_Y
);
1388 if (it
.current_y
> top_y
)
1395 if (it_method
== GET_FROM_DISPLAY_VECTOR
)
1397 /* We stopped on the last glyph of a display vector.
1398 Try and recompute. Hack alert! */
1399 if (charpos
< 2 || top
.charpos
>= charpos
)
1400 top_x
= it
.glyph_row
->x
;
1404 start_display (&it2
, w
, top
);
1405 move_it_to (&it2
, charpos
- 1, -1, -1, -1, MOVE_TO_POS
);
1406 get_next_display_element (&it2
);
1407 PRODUCE_GLYPHS (&it2
);
1408 if (ITERATOR_AT_END_OF_LINE_P (&it2
)
1409 || it2
.current_x
> it2
.last_visible_x
)
1410 top_x
= it
.glyph_row
->x
;
1413 top_x
= it2
.current_x
;
1414 top_y
= it2
.current_y
;
1418 else if (IT_CHARPOS (it
) != charpos
)
1420 Lisp_Object cpos
= make_number (charpos
);
1421 Lisp_Object spec
= Fget_char_property (cpos
, Qdisplay
, Qnil
);
1422 Lisp_Object string
= string_from_display_spec (spec
);
1423 int newline_in_string
= 0;
1425 if (STRINGP (string
))
1427 const char *s
= SSDATA (string
);
1428 const char *e
= s
+ SBYTES (string
);
1433 newline_in_string
= 1;
1438 /* The tricky code below is needed because there's a
1439 discrepancy between move_it_to and how we set cursor
1440 when the display line ends in a newline from a
1441 display string. move_it_to will stop _after_ such
1442 display strings, whereas set_cursor_from_row
1443 conspires with cursor_row_p to place the cursor on
1444 the first glyph produced from the display string. */
1446 /* We have overshoot PT because it is covered by a
1447 display property whose value is a string. If the
1448 string includes embedded newlines, we are also in the
1449 wrong display line. Backtrack to the correct line,
1450 where the display string begins. */
1451 if (newline_in_string
)
1453 Lisp_Object startpos
, endpos
;
1454 EMACS_INT start
, end
;
1458 /* Find the first and the last buffer positions
1459 covered by the display string. */
1461 Fnext_single_char_property_change (cpos
, Qdisplay
,
1464 Fprevious_single_char_property_change (endpos
, Qdisplay
,
1466 start
= XFASTINT (startpos
);
1467 end
= XFASTINT (endpos
);
1468 /* Move to the last buffer position before the
1469 display property. */
1470 start_display (&it3
, w
, top
);
1471 move_it_to (&it3
, start
- 1, -1, -1, -1, MOVE_TO_POS
);
1472 /* Move forward one more line if the position before
1473 the display string is a newline or if it is the
1474 rightmost character on a line that is
1475 continued or word-wrapped. */
1476 if (it3
.method
== GET_FROM_BUFFER
1478 move_it_by_lines (&it3
, 1);
1479 else if (move_it_in_display_line_to (&it3
, -1,
1483 == MOVE_LINE_CONTINUED
)
1485 move_it_by_lines (&it3
, 1);
1486 /* When we are under word-wrap, the #$@%!
1487 move_it_by_lines moves 2 lines, so we need to
1489 if (it3
.line_wrap
== WORD_WRAP
)
1490 move_it_by_lines (&it3
, -1);
1493 /* Record the vertical coordinate of the display
1494 line where we wound up. */
1495 top_y
= it3
.current_y
;
1498 /* When characters are reordered for display,
1499 the character displayed to the left of the
1500 display string could be _after_ the display
1501 property in the logical order. Use the
1502 smallest vertical position of these two. */
1503 start_display (&it3
, w
, top
);
1504 move_it_to (&it3
, end
+ 1, -1, -1, -1, MOVE_TO_POS
);
1505 if (it3
.current_y
< top_y
)
1506 top_y
= it3
.current_y
;
1508 /* Move from the top of the window to the beginning
1509 of the display line where the display string
1511 start_display (&it3
, w
, top
);
1512 move_it_to (&it3
, -1, 0, top_y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
1513 /* If it3_moved stays zero after the 'while' loop
1514 below, that means we already were at a newline
1515 before the loop (e.g., the display string begins
1516 with a newline), so we don't need to (and cannot)
1517 inspect the glyphs of it3.glyph_row, because
1518 PRODUCE_GLYPHS will not produce anything for a
1519 newline, and thus it3.glyph_row stays at its
1520 stale content it got at top of the window. */
1522 /* Finally, advance the iterator until we hit the
1523 first display element whose character position is
1524 CHARPOS, or until the first newline from the
1525 display string, which signals the end of the
1527 while (get_next_display_element (&it3
))
1529 PRODUCE_GLYPHS (&it3
);
1530 if (IT_CHARPOS (it3
) == charpos
1531 || ITERATOR_AT_END_OF_LINE_P (&it3
))
1534 set_iterator_to_next (&it3
, 0);
1536 top_x
= it3
.current_x
- it3
.pixel_width
;
1537 /* Normally, we would exit the above loop because we
1538 found the display element whose character
1539 position is CHARPOS. For the contingency that we
1540 didn't, and stopped at the first newline from the
1541 display string, move back over the glyphs
1542 produced from the string, until we find the
1543 rightmost glyph not from the string. */
1545 && IT_CHARPOS (it3
) != charpos
&& EQ (it3
.object
, string
))
1547 struct glyph
*g
= it3
.glyph_row
->glyphs
[TEXT_AREA
]
1548 + it3
.glyph_row
->used
[TEXT_AREA
];
1550 while (EQ ((g
- 1)->object
, string
))
1553 top_x
-= g
->pixel_width
;
1555 eassert (g
< it3
.glyph_row
->glyphs
[TEXT_AREA
]
1556 + it3
.glyph_row
->used
[TEXT_AREA
]);
1562 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1563 *rtop
= max (0, window_top_y
- top_y
);
1564 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1565 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1566 - max (top_y
, window_top_y
)));
1572 /* We were asked to provide info about WINDOW_END. */
1574 void *it2data
= NULL
;
1576 SAVE_IT (it2
, it
, it2data
);
1577 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1578 move_it_by_lines (&it
, 1);
1579 if (charpos
< IT_CHARPOS (it
)
1580 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1583 RESTORE_IT (&it2
, &it2
, it2data
);
1584 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1586 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1587 *rtop
= max (0, -it2
.current_y
);
1588 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1589 - it
.last_visible_y
));
1590 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1592 - max (it2
.current_y
,
1593 WINDOW_HEADER_LINE_HEIGHT (w
))));
1597 bidi_unshelve_cache (it2data
, 1);
1599 bidi_unshelve_cache (itdata
, 0);
1602 set_buffer_internal_1 (old_buffer
);
1604 current_header_line_height
= current_mode_line_height
= -1;
1606 if (visible_p
&& w
->hscroll
> 0)
1608 window_hscroll_limited (w
, WINDOW_XFRAME (w
))
1609 * WINDOW_FRAME_COLUMN_WIDTH (w
);
1612 /* Debugging code. */
1614 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1615 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1617 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1624 /* Return the next character from STR. Return in *LEN the length of
1625 the character. This is like STRING_CHAR_AND_LENGTH but never
1626 returns an invalid character. If we find one, we return a `?', but
1627 with the length of the invalid character. */
1630 string_char_and_length (const unsigned char *str
, int *len
)
1634 c
= STRING_CHAR_AND_LENGTH (str
, *len
);
1635 if (!CHAR_VALID_P (c
))
1636 /* We may not change the length here because other places in Emacs
1637 don't use this function, i.e. they silently accept invalid
1646 /* Given a position POS containing a valid character and byte position
1647 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1649 static struct text_pos
1650 string_pos_nchars_ahead (struct text_pos pos
, Lisp_Object string
, ptrdiff_t nchars
)
1652 eassert (STRINGP (string
) && nchars
>= 0);
1654 if (STRING_MULTIBYTE (string
))
1656 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1661 string_char_and_length (p
, &len
);
1664 BYTEPOS (pos
) += len
;
1668 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1674 /* Value is the text position, i.e. character and byte position,
1675 for character position CHARPOS in STRING. */
1677 static struct text_pos
1678 string_pos (ptrdiff_t charpos
, Lisp_Object string
)
1680 struct text_pos pos
;
1681 eassert (STRINGP (string
));
1682 eassert (charpos
>= 0);
1683 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1688 /* Value is a text position, i.e. character and byte position, for
1689 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1690 means recognize multibyte characters. */
1692 static struct text_pos
1693 c_string_pos (ptrdiff_t charpos
, const char *s
, int multibyte_p
)
1695 struct text_pos pos
;
1697 eassert (s
!= NULL
);
1698 eassert (charpos
>= 0);
1704 SET_TEXT_POS (pos
, 0, 0);
1707 string_char_and_length ((const unsigned char *) s
, &len
);
1710 BYTEPOS (pos
) += len
;
1714 SET_TEXT_POS (pos
, charpos
, charpos
);
1720 /* Value is the number of characters in C string S. MULTIBYTE_P
1721 non-zero means recognize multibyte characters. */
1724 number_of_chars (const char *s
, int multibyte_p
)
1730 ptrdiff_t rest
= strlen (s
);
1732 const unsigned char *p
= (const unsigned char *) s
;
1734 for (nchars
= 0; rest
> 0; ++nchars
)
1736 string_char_and_length (p
, &len
);
1737 rest
-= len
, p
+= len
;
1741 nchars
= strlen (s
);
1747 /* Compute byte position NEWPOS->bytepos corresponding to
1748 NEWPOS->charpos. POS is a known position in string STRING.
1749 NEWPOS->charpos must be >= POS.charpos. */
1752 compute_string_pos (struct text_pos
*newpos
, struct text_pos pos
, Lisp_Object string
)
1754 eassert (STRINGP (string
));
1755 eassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1757 if (STRING_MULTIBYTE (string
))
1758 *newpos
= string_pos_nchars_ahead (pos
, string
,
1759 CHARPOS (*newpos
) - CHARPOS (pos
));
1761 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1765 Return an estimation of the pixel height of mode or header lines on
1766 frame F. FACE_ID specifies what line's height to estimate. */
1769 estimate_mode_line_height (struct frame
*f
, enum face_id face_id
)
1771 #ifdef HAVE_WINDOW_SYSTEM
1772 if (FRAME_WINDOW_P (f
))
1774 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1776 /* This function is called so early when Emacs starts that the face
1777 cache and mode line face are not yet initialized. */
1778 if (FRAME_FACE_CACHE (f
))
1780 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1784 height
= FONT_HEIGHT (face
->font
);
1785 if (face
->box_line_width
> 0)
1786 height
+= 2 * face
->box_line_width
;
1797 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1798 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1799 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1800 not force the value into range. */
1803 pixel_to_glyph_coords (FRAME_PTR f
, register int pix_x
, register int pix_y
,
1804 int *x
, int *y
, NativeRectangle
*bounds
, int noclip
)
1807 #ifdef HAVE_WINDOW_SYSTEM
1808 if (FRAME_WINDOW_P (f
))
1810 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1811 even for negative values. */
1813 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1815 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1817 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1818 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1821 STORE_NATIVE_RECT (*bounds
,
1822 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1823 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1824 FRAME_COLUMN_WIDTH (f
) - 1,
1825 FRAME_LINE_HEIGHT (f
) - 1);
1831 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1832 pix_x
= FRAME_TOTAL_COLS (f
);
1836 else if (pix_y
> FRAME_LINES (f
))
1837 pix_y
= FRAME_LINES (f
);
1847 /* Find the glyph under window-relative coordinates X/Y in window W.
1848 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1849 strings. Return in *HPOS and *VPOS the row and column number of
1850 the glyph found. Return in *AREA the glyph area containing X.
1851 Value is a pointer to the glyph found or null if X/Y is not on
1852 text, or we can't tell because W's current matrix is not up to
1857 x_y_to_hpos_vpos (struct window
*w
, int x
, int y
, int *hpos
, int *vpos
,
1858 int *dx
, int *dy
, int *area
)
1860 struct glyph
*glyph
, *end
;
1861 struct glyph_row
*row
= NULL
;
1864 /* Find row containing Y. Give up if some row is not enabled. */
1865 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1867 row
= MATRIX_ROW (w
->current_matrix
, i
);
1868 if (!row
->enabled_p
)
1870 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1877 /* Give up if Y is not in the window. */
1878 if (i
== w
->current_matrix
->nrows
)
1881 /* Get the glyph area containing X. */
1882 if (w
->pseudo_window_p
)
1889 if (x
< window_box_left_offset (w
, TEXT_AREA
))
1891 *area
= LEFT_MARGIN_AREA
;
1892 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
1894 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
1897 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
1901 *area
= RIGHT_MARGIN_AREA
;
1902 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
1906 /* Find glyph containing X. */
1907 glyph
= row
->glyphs
[*area
];
1908 end
= glyph
+ row
->used
[*area
];
1910 while (glyph
< end
&& x
>= glyph
->pixel_width
)
1912 x
-= glyph
->pixel_width
;
1922 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
1925 *hpos
= glyph
- row
->glyphs
[*area
];
1929 /* Convert frame-relative x/y to coordinates relative to window W.
1930 Takes pseudo-windows into account. */
1933 frame_to_window_pixel_xy (struct window
*w
, int *x
, int *y
)
1935 if (w
->pseudo_window_p
)
1937 /* A pseudo-window is always full-width, and starts at the
1938 left edge of the frame, plus a frame border. */
1939 struct frame
*f
= XFRAME (w
->frame
);
1940 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
1941 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1945 *x
-= WINDOW_LEFT_EDGE_X (w
);
1946 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1950 #ifdef HAVE_WINDOW_SYSTEM
1953 Return in RECTS[] at most N clipping rectangles for glyph string S.
1954 Return the number of stored rectangles. */
1957 get_glyph_string_clip_rects (struct glyph_string
*s
, NativeRectangle
*rects
, int n
)
1964 if (s
->row
->full_width_p
)
1966 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1967 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
1968 r
.width
= WINDOW_TOTAL_WIDTH (s
->w
);
1970 /* Unless displaying a mode or menu bar line, which are always
1971 fully visible, clip to the visible part of the row. */
1972 if (s
->w
->pseudo_window_p
)
1973 r
.height
= s
->row
->visible_height
;
1975 r
.height
= s
->height
;
1979 /* This is a text line that may be partially visible. */
1980 r
.x
= window_box_left (s
->w
, s
->area
);
1981 r
.width
= window_box_width (s
->w
, s
->area
);
1982 r
.height
= s
->row
->visible_height
;
1986 if (r
.x
< s
->clip_head
->x
)
1988 if (r
.width
>= s
->clip_head
->x
- r
.x
)
1989 r
.width
-= s
->clip_head
->x
- r
.x
;
1992 r
.x
= s
->clip_head
->x
;
1995 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
1997 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
1998 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
2003 /* If S draws overlapping rows, it's sufficient to use the top and
2004 bottom of the window for clipping because this glyph string
2005 intentionally draws over other lines. */
2006 if (s
->for_overlaps
)
2008 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2009 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
2011 /* Alas, the above simple strategy does not work for the
2012 environments with anti-aliased text: if the same text is
2013 drawn onto the same place multiple times, it gets thicker.
2014 If the overlap we are processing is for the erased cursor, we
2015 take the intersection with the rectangle of the cursor. */
2016 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
2018 XRectangle rc
, r_save
= r
;
2020 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
2021 rc
.y
= s
->w
->phys_cursor
.y
;
2022 rc
.width
= s
->w
->phys_cursor_width
;
2023 rc
.height
= s
->w
->phys_cursor_height
;
2025 x_intersect_rectangles (&r_save
, &rc
, &r
);
2030 /* Don't use S->y for clipping because it doesn't take partially
2031 visible lines into account. For example, it can be negative for
2032 partially visible lines at the top of a window. */
2033 if (!s
->row
->full_width_p
2034 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2035 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2037 r
.y
= max (0, s
->row
->y
);
2040 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
2042 /* If drawing the cursor, don't let glyph draw outside its
2043 advertised boundaries. Cleartype does this under some circumstances. */
2044 if (s
->hl
== DRAW_CURSOR
)
2046 struct glyph
*glyph
= s
->first_glyph
;
2051 r
.width
-= s
->x
- r
.x
;
2054 r
.width
= min (r
.width
, glyph
->pixel_width
);
2056 /* If r.y is below window bottom, ensure that we still see a cursor. */
2057 height
= min (glyph
->ascent
+ glyph
->descent
,
2058 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
2059 max_y
= window_text_bottom_y (s
->w
) - height
;
2060 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
2061 if (s
->ybase
- glyph
->ascent
> max_y
)
2068 /* Don't draw cursor glyph taller than our actual glyph. */
2069 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
2070 if (height
< r
.height
)
2072 max_y
= r
.y
+ r
.height
;
2073 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
2074 r
.height
= min (max_y
- r
.y
, height
);
2081 XRectangle r_save
= r
;
2083 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
2087 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
2088 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
2090 #ifdef CONVERT_FROM_XRECT
2091 CONVERT_FROM_XRECT (r
, *rects
);
2099 /* If we are processing overlapping and allowed to return
2100 multiple clipping rectangles, we exclude the row of the glyph
2101 string from the clipping rectangle. This is to avoid drawing
2102 the same text on the environment with anti-aliasing. */
2103 #ifdef CONVERT_FROM_XRECT
2106 XRectangle
*rs
= rects
;
2108 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
2110 if (s
->for_overlaps
& OVERLAPS_PRED
)
2113 if (r
.y
+ r
.height
> row_y
)
2116 rs
[i
].height
= row_y
- r
.y
;
2122 if (s
->for_overlaps
& OVERLAPS_SUCC
)
2125 if (r
.y
< row_y
+ s
->row
->visible_height
)
2127 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
2129 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
2130 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
2139 #ifdef CONVERT_FROM_XRECT
2140 for (i
= 0; i
< n
; i
++)
2141 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
2148 Return in *NR the clipping rectangle for glyph string S. */
2151 get_glyph_string_clip_rect (struct glyph_string
*s
, NativeRectangle
*nr
)
2153 get_glyph_string_clip_rects (s
, nr
, 1);
2158 Return the position and height of the phys cursor in window W.
2159 Set w->phys_cursor_width to width of phys cursor.
2163 get_phys_cursor_geometry (struct window
*w
, struct glyph_row
*row
,
2164 struct glyph
*glyph
, int *xp
, int *yp
, int *heightp
)
2166 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2167 int x
, y
, wd
, h
, h0
, y0
;
2169 /* Compute the width of the rectangle to draw. If on a stretch
2170 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2171 rectangle as wide as the glyph, but use a canonical character
2173 wd
= glyph
->pixel_width
- 1;
2174 #if defined (HAVE_NTGUI) || defined (HAVE_NS)
2178 x
= w
->phys_cursor
.x
;
2185 if (glyph
->type
== STRETCH_GLYPH
2186 && !x_stretch_cursor_p
)
2187 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
2188 w
->phys_cursor_width
= wd
;
2190 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
2192 /* If y is below window bottom, ensure that we still see a cursor. */
2193 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
2195 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
2196 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
2198 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
2201 h
= max (h
- (y0
- y
) + 1, h0
);
2206 y0
= window_text_bottom_y (w
) - h0
;
2214 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
2215 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
2220 * Remember which glyph the mouse is over.
2224 remember_mouse_glyph (struct frame
*f
, int gx
, int gy
, NativeRectangle
*rect
)
2228 struct glyph_row
*r
, *gr
, *end_row
;
2229 enum window_part part
;
2230 enum glyph_row_area area
;
2231 int x
, y
, width
, height
;
2233 /* Try to determine frame pixel position and size of the glyph under
2234 frame pixel coordinates X/Y on frame F. */
2236 if (!f
->glyphs_initialized_p
2237 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, 0),
2240 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2241 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2245 w
= XWINDOW (window
);
2246 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
2247 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
2249 x
= window_relative_x_coord (w
, part
, gx
);
2250 y
= gy
- WINDOW_TOP_EDGE_Y (w
);
2252 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
2253 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
2255 if (w
->pseudo_window_p
)
2258 part
= ON_MODE_LINE
; /* Don't adjust margin. */
2264 case ON_LEFT_MARGIN
:
2265 area
= LEFT_MARGIN_AREA
;
2268 case ON_RIGHT_MARGIN
:
2269 area
= RIGHT_MARGIN_AREA
;
2272 case ON_HEADER_LINE
:
2274 gr
= (part
== ON_HEADER_LINE
2275 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
2276 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
2279 goto text_glyph_row_found
;
2286 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2287 if (r
->y
+ r
->height
> y
)
2293 text_glyph_row_found
:
2296 struct glyph
*g
= gr
->glyphs
[area
];
2297 struct glyph
*end
= g
+ gr
->used
[area
];
2299 height
= gr
->height
;
2300 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2301 if (gx
+ g
->pixel_width
> x
)
2306 if (g
->type
== IMAGE_GLYPH
)
2308 /* Don't remember when mouse is over image, as
2309 image may have hot-spots. */
2310 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2313 width
= g
->pixel_width
;
2317 /* Use nominal char spacing at end of line. */
2319 gx
+= (x
/ width
) * width
;
2322 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2323 gx
+= window_box_left_offset (w
, area
);
2327 /* Use nominal line height at end of window. */
2328 gx
= (x
/ width
) * width
;
2330 gy
+= (y
/ height
) * height
;
2334 case ON_LEFT_FRINGE
:
2335 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2336 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2337 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2338 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2341 case ON_RIGHT_FRINGE
:
2342 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2343 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2344 : window_box_right_offset (w
, TEXT_AREA
));
2345 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2349 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2351 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2352 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2353 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2355 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2359 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2360 if (r
->y
+ r
->height
> y
)
2367 height
= gr
->height
;
2370 /* Use nominal line height at end of window. */
2372 gy
+= (y
/ height
) * height
;
2379 /* If there is no glyph under the mouse, then we divide the screen
2380 into a grid of the smallest glyph in the frame, and use that
2383 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2384 round down even for negative values. */
2390 gx
= (gx
/ width
) * width
;
2391 gy
= (gy
/ height
) * height
;
2396 gx
+= WINDOW_LEFT_EDGE_X (w
);
2397 gy
+= WINDOW_TOP_EDGE_Y (w
);
2400 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2402 /* Visible feedback for debugging. */
2405 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2406 f
->output_data
.x
->normal_gc
,
2407 gx
, gy
, width
, height
);
2413 #endif /* HAVE_WINDOW_SYSTEM */
2416 /***********************************************************************
2417 Lisp form evaluation
2418 ***********************************************************************/
2420 /* Error handler for safe_eval and safe_call. */
2423 safe_eval_handler (Lisp_Object arg
, ptrdiff_t nargs
, Lisp_Object
*args
)
2425 add_to_log ("Error during redisplay: %S signaled %S",
2426 Flist (nargs
, args
), arg
);
2430 /* Call function FUNC with the rest of NARGS - 1 arguments
2431 following. Return the result, or nil if something went
2432 wrong. Prevent redisplay during the evaluation. */
2435 safe_call (ptrdiff_t nargs
, Lisp_Object func
, ...)
2439 if (inhibit_eval_during_redisplay
)
2445 ptrdiff_t count
= SPECPDL_INDEX ();
2446 struct gcpro gcpro1
;
2447 Lisp_Object
*args
= alloca (nargs
* word_size
);
2450 va_start (ap
, func
);
2451 for (i
= 1; i
< nargs
; i
++)
2452 args
[i
] = va_arg (ap
, Lisp_Object
);
2456 gcpro1
.nvars
= nargs
;
2457 specbind (Qinhibit_redisplay
, Qt
);
2458 /* Use Qt to ensure debugger does not run,
2459 so there is no possibility of wanting to redisplay. */
2460 val
= internal_condition_case_n (Ffuncall
, nargs
, args
, Qt
,
2463 val
= unbind_to (count
, val
);
2470 /* Call function FN with one argument ARG.
2471 Return the result, or nil if something went wrong. */
2474 safe_call1 (Lisp_Object fn
, Lisp_Object arg
)
2476 return safe_call (2, fn
, arg
);
2479 static Lisp_Object Qeval
;
2482 safe_eval (Lisp_Object sexpr
)
2484 return safe_call1 (Qeval
, sexpr
);
2487 /* Call function FN with two arguments ARG1 and ARG2.
2488 Return the result, or nil if something went wrong. */
2491 safe_call2 (Lisp_Object fn
, Lisp_Object arg1
, Lisp_Object arg2
)
2493 return safe_call (3, fn
, arg1
, arg2
);
2498 /***********************************************************************
2500 ***********************************************************************/
2504 /* Define CHECK_IT to perform sanity checks on iterators.
2505 This is for debugging. It is too slow to do unconditionally. */
2508 check_it (struct it
*it
)
2510 if (it
->method
== GET_FROM_STRING
)
2512 eassert (STRINGP (it
->string
));
2513 eassert (IT_STRING_CHARPOS (*it
) >= 0);
2517 eassert (IT_STRING_CHARPOS (*it
) < 0);
2518 if (it
->method
== GET_FROM_BUFFER
)
2520 /* Check that character and byte positions agree. */
2521 eassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2526 eassert (it
->current
.dpvec_index
>= 0);
2528 eassert (it
->current
.dpvec_index
< 0);
2531 #define CHECK_IT(IT) check_it ((IT))
2535 #define CHECK_IT(IT) (void) 0
2540 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2542 /* Check that the window end of window W is what we expect it
2543 to be---the last row in the current matrix displaying text. */
2546 check_window_end (struct window
*w
)
2548 if (!MINI_WINDOW_P (w
)
2549 && !NILP (w
->window_end_valid
))
2551 struct glyph_row
*row
;
2552 eassert ((row
= MATRIX_ROW (w
->current_matrix
,
2553 XFASTINT (w
->window_end_vpos
)),
2555 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2556 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2560 #define CHECK_WINDOW_END(W) check_window_end ((W))
2564 #define CHECK_WINDOW_END(W) (void) 0
2566 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
2570 /***********************************************************************
2571 Iterator initialization
2572 ***********************************************************************/
2574 /* Initialize IT for displaying current_buffer in window W, starting
2575 at character position CHARPOS. CHARPOS < 0 means that no buffer
2576 position is specified which is useful when the iterator is assigned
2577 a position later. BYTEPOS is the byte position corresponding to
2578 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2580 If ROW is not null, calls to produce_glyphs with IT as parameter
2581 will produce glyphs in that row.
2583 BASE_FACE_ID is the id of a base face to use. It must be one of
2584 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2585 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2586 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2588 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2589 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2590 will be initialized to use the corresponding mode line glyph row of
2591 the desired matrix of W. */
2594 init_iterator (struct it
*it
, struct window
*w
,
2595 ptrdiff_t charpos
, ptrdiff_t bytepos
,
2596 struct glyph_row
*row
, enum face_id base_face_id
)
2598 int highlight_region_p
;
2599 enum face_id remapped_base_face_id
= base_face_id
;
2601 /* Some precondition checks. */
2602 eassert (w
!= NULL
&& it
!= NULL
);
2603 eassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2606 /* If face attributes have been changed since the last redisplay,
2607 free realized faces now because they depend on face definitions
2608 that might have changed. Don't free faces while there might be
2609 desired matrices pending which reference these faces. */
2610 if (face_change_count
&& !inhibit_free_realized_faces
)
2612 face_change_count
= 0;
2613 free_all_realized_faces (Qnil
);
2616 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2617 if (! NILP (Vface_remapping_alist
))
2618 remapped_base_face_id
2619 = lookup_basic_face (XFRAME (w
->frame
), base_face_id
);
2621 /* Use one of the mode line rows of W's desired matrix if
2625 if (base_face_id
== MODE_LINE_FACE_ID
2626 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2627 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2628 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2629 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2633 memset (it
, 0, sizeof *it
);
2634 it
->current
.overlay_string_index
= -1;
2635 it
->current
.dpvec_index
= -1;
2636 it
->base_face_id
= remapped_base_face_id
;
2638 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2639 it
->paragraph_embedding
= L2R
;
2640 it
->bidi_it
.string
.lstring
= Qnil
;
2641 it
->bidi_it
.string
.s
= NULL
;
2642 it
->bidi_it
.string
.bufpos
= 0;
2644 /* The window in which we iterate over current_buffer: */
2645 XSETWINDOW (it
->window
, w
);
2647 it
->f
= XFRAME (w
->frame
);
2651 /* Extra space between lines (on window systems only). */
2652 if (base_face_id
== DEFAULT_FACE_ID
2653 && FRAME_WINDOW_P (it
->f
))
2655 if (NATNUMP (BVAR (current_buffer
, extra_line_spacing
)))
2656 it
->extra_line_spacing
= XFASTINT (BVAR (current_buffer
, extra_line_spacing
));
2657 else if (FLOATP (BVAR (current_buffer
, extra_line_spacing
)))
2658 it
->extra_line_spacing
= (XFLOAT_DATA (BVAR (current_buffer
, extra_line_spacing
))
2659 * FRAME_LINE_HEIGHT (it
->f
));
2660 else if (it
->f
->extra_line_spacing
> 0)
2661 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2662 it
->max_extra_line_spacing
= 0;
2665 /* If realized faces have been removed, e.g. because of face
2666 attribute changes of named faces, recompute them. When running
2667 in batch mode, the face cache of the initial frame is null. If
2668 we happen to get called, make a dummy face cache. */
2669 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2670 init_frame_faces (it
->f
);
2671 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2672 recompute_basic_faces (it
->f
);
2674 /* Current value of the `slice', `space-width', and 'height' properties. */
2675 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2676 it
->space_width
= Qnil
;
2677 it
->font_height
= Qnil
;
2678 it
->override_ascent
= -1;
2680 /* Are control characters displayed as `^C'? */
2681 it
->ctl_arrow_p
= !NILP (BVAR (current_buffer
, ctl_arrow
));
2683 /* -1 means everything between a CR and the following line end
2684 is invisible. >0 means lines indented more than this value are
2686 it
->selective
= (INTEGERP (BVAR (current_buffer
, selective_display
))
2688 (-1, XINT (BVAR (current_buffer
, selective_display
)),
2690 : (!NILP (BVAR (current_buffer
, selective_display
))
2692 it
->selective_display_ellipsis_p
2693 = !NILP (BVAR (current_buffer
, selective_display_ellipses
));
2695 /* Display table to use. */
2696 it
->dp
= window_display_table (w
);
2698 /* Are multibyte characters enabled in current_buffer? */
2699 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
2701 /* Non-zero if we should highlight the region. */
2703 = (!NILP (Vtransient_mark_mode
)
2704 && !NILP (BVAR (current_buffer
, mark_active
))
2705 && XMARKER (BVAR (current_buffer
, mark
))->buffer
!= 0);
2707 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2708 start and end of a visible region in window IT->w. Set both to
2709 -1 to indicate no region. */
2710 if (highlight_region_p
2711 /* Maybe highlight only in selected window. */
2712 && (/* Either show region everywhere. */
2713 highlight_nonselected_windows
2714 /* Or show region in the selected window. */
2715 || w
== XWINDOW (selected_window
)
2716 /* Or show the region if we are in the mini-buffer and W is
2717 the window the mini-buffer refers to. */
2718 || (MINI_WINDOW_P (XWINDOW (selected_window
))
2719 && WINDOWP (minibuf_selected_window
)
2720 && w
== XWINDOW (minibuf_selected_window
))))
2722 ptrdiff_t markpos
= marker_position (BVAR (current_buffer
, mark
));
2723 it
->region_beg_charpos
= min (PT
, markpos
);
2724 it
->region_end_charpos
= max (PT
, markpos
);
2727 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
2729 /* Get the position at which the redisplay_end_trigger hook should
2730 be run, if it is to be run at all. */
2731 if (MARKERP (w
->redisplay_end_trigger
)
2732 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2733 it
->redisplay_end_trigger_charpos
2734 = marker_position (w
->redisplay_end_trigger
);
2735 else if (INTEGERP (w
->redisplay_end_trigger
))
2736 it
->redisplay_end_trigger_charpos
=
2737 clip_to_bounds (PTRDIFF_MIN
, XINT (w
->redisplay_end_trigger
), PTRDIFF_MAX
);
2739 it
->tab_width
= SANE_TAB_WIDTH (current_buffer
);
2741 /* Are lines in the display truncated? */
2742 if (base_face_id
!= DEFAULT_FACE_ID
2744 || (! WINDOW_FULL_WIDTH_P (it
->w
)
2745 && ((!NILP (Vtruncate_partial_width_windows
)
2746 && !INTEGERP (Vtruncate_partial_width_windows
))
2747 || (INTEGERP (Vtruncate_partial_width_windows
)
2748 && (WINDOW_TOTAL_COLS (it
->w
)
2749 < XINT (Vtruncate_partial_width_windows
))))))
2750 it
->line_wrap
= TRUNCATE
;
2751 else if (NILP (BVAR (current_buffer
, truncate_lines
)))
2752 it
->line_wrap
= NILP (BVAR (current_buffer
, word_wrap
))
2753 ? WINDOW_WRAP
: WORD_WRAP
;
2755 it
->line_wrap
= TRUNCATE
;
2757 /* Get dimensions of truncation and continuation glyphs. These are
2758 displayed as fringe bitmaps under X, but we need them for such
2759 frames when the fringes are turned off. But leave the dimensions
2760 zero for tooltip frames, as these glyphs look ugly there and also
2761 sabotage calculations of tooltip dimensions in x-show-tip. */
2762 #ifdef HAVE_WINDOW_SYSTEM
2763 if (!(FRAME_WINDOW_P (it
->f
)
2764 && FRAMEP (tip_frame
)
2765 && it
->f
== XFRAME (tip_frame
)))
2768 if (it
->line_wrap
== TRUNCATE
)
2770 /* We will need the truncation glyph. */
2771 eassert (it
->glyph_row
== NULL
);
2772 produce_special_glyphs (it
, IT_TRUNCATION
);
2773 it
->truncation_pixel_width
= it
->pixel_width
;
2777 /* We will need the continuation glyph. */
2778 eassert (it
->glyph_row
== NULL
);
2779 produce_special_glyphs (it
, IT_CONTINUATION
);
2780 it
->continuation_pixel_width
= it
->pixel_width
;
2784 /* Reset these values to zero because the produce_special_glyphs
2785 above has changed them. */
2786 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2787 it
->phys_ascent
= it
->phys_descent
= 0;
2789 /* Set this after getting the dimensions of truncation and
2790 continuation glyphs, so that we don't produce glyphs when calling
2791 produce_special_glyphs, above. */
2792 it
->glyph_row
= row
;
2793 it
->area
= TEXT_AREA
;
2795 /* Forget any previous info about this row being reversed. */
2797 it
->glyph_row
->reversed_p
= 0;
2799 /* Get the dimensions of the display area. The display area
2800 consists of the visible window area plus a horizontally scrolled
2801 part to the left of the window. All x-values are relative to the
2802 start of this total display area. */
2803 if (base_face_id
!= DEFAULT_FACE_ID
)
2805 /* Mode lines, menu bar in terminal frames. */
2806 it
->first_visible_x
= 0;
2807 it
->last_visible_x
= WINDOW_TOTAL_WIDTH (w
);
2811 it
->first_visible_x
=
2812 window_hscroll_limited (it
->w
, it
->f
) * FRAME_COLUMN_WIDTH (it
->f
);
2813 it
->last_visible_x
= (it
->first_visible_x
2814 + window_box_width (w
, TEXT_AREA
));
2816 /* If we truncate lines, leave room for the truncation glyph(s) at
2817 the right margin. Otherwise, leave room for the continuation
2818 glyph(s). Done only if the window has no fringes. Since we
2819 don't know at this point whether there will be any R2L lines in
2820 the window, we reserve space for truncation/continuation glyphs
2821 even if only one of the fringes is absent. */
2822 if (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
2823 || (it
->bidi_p
&& WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0))
2825 if (it
->line_wrap
== TRUNCATE
)
2826 it
->last_visible_x
-= it
->truncation_pixel_width
;
2828 it
->last_visible_x
-= it
->continuation_pixel_width
;
2831 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
2832 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
2835 /* Leave room for a border glyph. */
2836 if (!FRAME_WINDOW_P (it
->f
)
2837 && !WINDOW_RIGHTMOST_P (it
->w
))
2838 it
->last_visible_x
-= 1;
2840 it
->last_visible_y
= window_text_bottom_y (w
);
2842 /* For mode lines and alike, arrange for the first glyph having a
2843 left box line if the face specifies a box. */
2844 if (base_face_id
!= DEFAULT_FACE_ID
)
2848 it
->face_id
= remapped_base_face_id
;
2850 /* If we have a boxed mode line, make the first character appear
2851 with a left box line. */
2852 face
= FACE_FROM_ID (it
->f
, remapped_base_face_id
);
2853 if (face
->box
!= FACE_NO_BOX
)
2854 it
->start_of_box_run_p
= 1;
2857 /* If a buffer position was specified, set the iterator there,
2858 getting overlays and face properties from that position. */
2859 if (charpos
>= BUF_BEG (current_buffer
))
2861 it
->end_charpos
= ZV
;
2862 IT_CHARPOS (*it
) = charpos
;
2864 /* We will rely on `reseat' to set this up properly, via
2865 handle_face_prop. */
2866 it
->face_id
= it
->base_face_id
;
2868 /* Compute byte position if not specified. */
2869 if (bytepos
< charpos
)
2870 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
2872 IT_BYTEPOS (*it
) = bytepos
;
2874 it
->start
= it
->current
;
2875 /* Do we need to reorder bidirectional text? Not if this is a
2876 unibyte buffer: by definition, none of the single-byte
2877 characters are strong R2L, so no reordering is needed. And
2878 bidi.c doesn't support unibyte buffers anyway. Also, don't
2879 reorder while we are loading loadup.el, since the tables of
2880 character properties needed for reordering are not yet
2884 && !NILP (BVAR (current_buffer
, bidi_display_reordering
))
2887 /* If we are to reorder bidirectional text, init the bidi
2891 /* Note the paragraph direction that this buffer wants to
2893 if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2895 it
->paragraph_embedding
= L2R
;
2896 else if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2898 it
->paragraph_embedding
= R2L
;
2900 it
->paragraph_embedding
= NEUTRAL_DIR
;
2901 bidi_unshelve_cache (NULL
, 0);
2902 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
2906 /* Compute faces etc. */
2907 reseat (it
, it
->current
.pos
, 1);
2914 /* Initialize IT for the display of window W with window start POS. */
2917 start_display (struct it
*it
, struct window
*w
, struct text_pos pos
)
2919 struct glyph_row
*row
;
2920 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
2922 row
= w
->desired_matrix
->rows
+ first_vpos
;
2923 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
2924 it
->first_vpos
= first_vpos
;
2926 /* Don't reseat to previous visible line start if current start
2927 position is in a string or image. */
2928 if (it
->method
== GET_FROM_BUFFER
&& it
->line_wrap
!= TRUNCATE
)
2930 int start_at_line_beg_p
;
2931 int first_y
= it
->current_y
;
2933 /* If window start is not at a line start, skip forward to POS to
2934 get the correct continuation lines width. */
2935 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
2936 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
2937 if (!start_at_line_beg_p
)
2941 reseat_at_previous_visible_line_start (it
);
2942 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
2944 new_x
= it
->current_x
+ it
->pixel_width
;
2946 /* If lines are continued, this line may end in the middle
2947 of a multi-glyph character (e.g. a control character
2948 displayed as \003, or in the middle of an overlay
2949 string). In this case move_it_to above will not have
2950 taken us to the start of the continuation line but to the
2951 end of the continued line. */
2952 if (it
->current_x
> 0
2953 && it
->line_wrap
!= TRUNCATE
/* Lines are continued. */
2954 && (/* And glyph doesn't fit on the line. */
2955 new_x
> it
->last_visible_x
2956 /* Or it fits exactly and we're on a window
2958 || (new_x
== it
->last_visible_x
2959 && FRAME_WINDOW_P (it
->f
)
2960 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
2961 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
2962 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
2964 if ((it
->current
.dpvec_index
>= 0
2965 || it
->current
.overlay_string_index
>= 0)
2966 /* If we are on a newline from a display vector or
2967 overlay string, then we are already at the end of
2968 a screen line; no need to go to the next line in
2969 that case, as this line is not really continued.
2970 (If we do go to the next line, C-e will not DTRT.) */
2973 set_iterator_to_next (it
, 1);
2974 move_it_in_display_line_to (it
, -1, -1, 0);
2977 it
->continuation_lines_width
+= it
->current_x
;
2979 /* If the character at POS is displayed via a display
2980 vector, move_it_to above stops at the final glyph of
2981 IT->dpvec. To make the caller redisplay that character
2982 again (a.k.a. start at POS), we need to reset the
2983 dpvec_index to the beginning of IT->dpvec. */
2984 else if (it
->current
.dpvec_index
>= 0)
2985 it
->current
.dpvec_index
= 0;
2987 /* We're starting a new display line, not affected by the
2988 height of the continued line, so clear the appropriate
2989 fields in the iterator structure. */
2990 it
->max_ascent
= it
->max_descent
= 0;
2991 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
2993 it
->current_y
= first_y
;
2995 it
->current_x
= it
->hpos
= 0;
3001 /* Return 1 if POS is a position in ellipses displayed for invisible
3002 text. W is the window we display, for text property lookup. */
3005 in_ellipses_for_invisible_text_p (struct display_pos
*pos
, struct window
*w
)
3007 Lisp_Object prop
, window
;
3009 ptrdiff_t charpos
= CHARPOS (pos
->pos
);
3011 /* If POS specifies a position in a display vector, this might
3012 be for an ellipsis displayed for invisible text. We won't
3013 get the iterator set up for delivering that ellipsis unless
3014 we make sure that it gets aware of the invisible text. */
3015 if (pos
->dpvec_index
>= 0
3016 && pos
->overlay_string_index
< 0
3017 && CHARPOS (pos
->string_pos
) < 0
3019 && (XSETWINDOW (window
, w
),
3020 prop
= Fget_char_property (make_number (charpos
),
3021 Qinvisible
, window
),
3022 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
3024 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
3026 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
3033 /* Initialize IT for stepping through current_buffer in window W,
3034 starting at position POS that includes overlay string and display
3035 vector/ control character translation position information. Value
3036 is zero if there are overlay strings with newlines at POS. */
3039 init_from_display_pos (struct it
*it
, struct window
*w
, struct display_pos
*pos
)
3041 ptrdiff_t charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
3042 int i
, overlay_strings_with_newlines
= 0;
3044 /* If POS specifies a position in a display vector, this might
3045 be for an ellipsis displayed for invisible text. We won't
3046 get the iterator set up for delivering that ellipsis unless
3047 we make sure that it gets aware of the invisible text. */
3048 if (in_ellipses_for_invisible_text_p (pos
, w
))
3054 /* Keep in mind: the call to reseat in init_iterator skips invisible
3055 text, so we might end up at a position different from POS. This
3056 is only a problem when POS is a row start after a newline and an
3057 overlay starts there with an after-string, and the overlay has an
3058 invisible property. Since we don't skip invisible text in
3059 display_line and elsewhere immediately after consuming the
3060 newline before the row start, such a POS will not be in a string,
3061 but the call to init_iterator below will move us to the
3063 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
3065 /* This only scans the current chunk -- it should scan all chunks.
3066 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
3067 to 16 in 22.1 to make this a lesser problem. */
3068 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
3070 const char *s
= SSDATA (it
->overlay_strings
[i
]);
3071 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
3073 while (s
< e
&& *s
!= '\n')
3078 overlay_strings_with_newlines
= 1;
3083 /* If position is within an overlay string, set up IT to the right
3085 if (pos
->overlay_string_index
>= 0)
3089 /* If the first overlay string happens to have a `display'
3090 property for an image, the iterator will be set up for that
3091 image, and we have to undo that setup first before we can
3092 correct the overlay string index. */
3093 if (it
->method
== GET_FROM_IMAGE
)
3096 /* We already have the first chunk of overlay strings in
3097 IT->overlay_strings. Load more until the one for
3098 pos->overlay_string_index is in IT->overlay_strings. */
3099 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
3101 ptrdiff_t n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
3102 it
->current
.overlay_string_index
= 0;
3105 load_overlay_strings (it
, 0);
3106 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
3110 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
3111 relative_index
= (it
->current
.overlay_string_index
3112 % OVERLAY_STRING_CHUNK_SIZE
);
3113 it
->string
= it
->overlay_strings
[relative_index
];
3114 eassert (STRINGP (it
->string
));
3115 it
->current
.string_pos
= pos
->string_pos
;
3116 it
->method
= GET_FROM_STRING
;
3117 it
->end_charpos
= SCHARS (it
->string
);
3118 /* Set up the bidi iterator for this overlay string. */
3121 it
->bidi_it
.string
.lstring
= it
->string
;
3122 it
->bidi_it
.string
.s
= NULL
;
3123 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
3124 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
3125 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
3126 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
3127 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3128 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3130 /* Synchronize the state of the bidi iterator with
3131 pos->string_pos. For any string position other than
3132 zero, this will be done automagically when we resume
3133 iteration over the string and get_visually_first_element
3134 is called. But if string_pos is zero, and the string is
3135 to be reordered for display, we need to resync manually,
3136 since it could be that the iteration state recorded in
3137 pos ended at string_pos of 0 moving backwards in string. */
3138 if (CHARPOS (pos
->string_pos
) == 0)
3140 get_visually_first_element (it
);
3141 if (IT_STRING_CHARPOS (*it
) != 0)
3144 eassert (it
->bidi_it
.charpos
< it
->bidi_it
.string
.schars
);
3145 bidi_move_to_visually_next (&it
->bidi_it
);
3146 } while (it
->bidi_it
.charpos
!= 0);
3148 eassert (IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
3149 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
);
3153 if (CHARPOS (pos
->string_pos
) >= 0)
3155 /* Recorded position is not in an overlay string, but in another
3156 string. This can only be a string from a `display' property.
3157 IT should already be filled with that string. */
3158 it
->current
.string_pos
= pos
->string_pos
;
3159 eassert (STRINGP (it
->string
));
3161 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3162 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3165 /* Restore position in display vector translations, control
3166 character translations or ellipses. */
3167 if (pos
->dpvec_index
>= 0)
3169 if (it
->dpvec
== NULL
)
3170 get_next_display_element (it
);
3171 eassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
3172 it
->current
.dpvec_index
= pos
->dpvec_index
;
3176 return !overlay_strings_with_newlines
;
3180 /* Initialize IT for stepping through current_buffer in window W
3181 starting at ROW->start. */
3184 init_to_row_start (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3186 init_from_display_pos (it
, w
, &row
->start
);
3187 it
->start
= row
->start
;
3188 it
->continuation_lines_width
= row
->continuation_lines_width
;
3193 /* Initialize IT for stepping through current_buffer in window W
3194 starting in the line following ROW, i.e. starting at ROW->end.
3195 Value is zero if there are overlay strings with newlines at ROW's
3199 init_to_row_end (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3203 if (init_from_display_pos (it
, w
, &row
->end
))
3205 if (row
->continued_p
)
3206 it
->continuation_lines_width
3207 = row
->continuation_lines_width
+ row
->pixel_width
;
3218 /***********************************************************************
3220 ***********************************************************************/
3222 /* Called when IT reaches IT->stop_charpos. Handle text property and
3223 overlay changes. Set IT->stop_charpos to the next position where
3227 handle_stop (struct it
*it
)
3229 enum prop_handled handled
;
3230 int handle_overlay_change_p
;
3234 it
->current
.dpvec_index
= -1;
3235 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
3236 it
->ignore_overlay_strings_at_pos_p
= 0;
3239 /* Use face of preceding text for ellipsis (if invisible) */
3240 if (it
->selective_display_ellipsis_p
)
3241 it
->saved_face_id
= it
->face_id
;
3245 handled
= HANDLED_NORMALLY
;
3247 /* Call text property handlers. */
3248 for (p
= it_props
; p
->handler
; ++p
)
3250 handled
= p
->handler (it
);
3252 if (handled
== HANDLED_RECOMPUTE_PROPS
)
3254 else if (handled
== HANDLED_RETURN
)
3256 /* We still want to show before and after strings from
3257 overlays even if the actual buffer text is replaced. */
3258 if (!handle_overlay_change_p
3260 /* Don't call get_overlay_strings_1 if we already
3261 have overlay strings loaded, because doing so
3262 will load them again and push the iterator state
3263 onto the stack one more time, which is not
3264 expected by the rest of the code that processes
3266 || (it
->current
.overlay_string_index
< 0
3267 ? !get_overlay_strings_1 (it
, 0, 0)
3271 setup_for_ellipsis (it
, 0);
3272 /* When handling a display spec, we might load an
3273 empty string. In that case, discard it here. We
3274 used to discard it in handle_single_display_spec,
3275 but that causes get_overlay_strings_1, above, to
3276 ignore overlay strings that we must check. */
3277 if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3281 else if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3285 it
->ignore_overlay_strings_at_pos_p
= 1;
3286 it
->string_from_display_prop_p
= 0;
3287 it
->from_disp_prop_p
= 0;
3288 handle_overlay_change_p
= 0;
3290 handled
= HANDLED_RECOMPUTE_PROPS
;
3293 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
3294 handle_overlay_change_p
= 0;
3297 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
3299 /* Don't check for overlay strings below when set to deliver
3300 characters from a display vector. */
3301 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
3302 handle_overlay_change_p
= 0;
3304 /* Handle overlay changes.
3305 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3306 if it finds overlays. */
3307 if (handle_overlay_change_p
)
3308 handled
= handle_overlay_change (it
);
3313 setup_for_ellipsis (it
, 0);
3317 while (handled
== HANDLED_RECOMPUTE_PROPS
);
3319 /* Determine where to stop next. */
3320 if (handled
== HANDLED_NORMALLY
)
3321 compute_stop_pos (it
);
3325 /* Compute IT->stop_charpos from text property and overlay change
3326 information for IT's current position. */
3329 compute_stop_pos (struct it
*it
)
3331 register INTERVAL iv
, next_iv
;
3332 Lisp_Object object
, limit
, position
;
3333 ptrdiff_t charpos
, bytepos
;
3335 if (STRINGP (it
->string
))
3337 /* Strings are usually short, so don't limit the search for
3339 it
->stop_charpos
= it
->end_charpos
;
3340 object
= it
->string
;
3342 charpos
= IT_STRING_CHARPOS (*it
);
3343 bytepos
= IT_STRING_BYTEPOS (*it
);
3349 /* If end_charpos is out of range for some reason, such as a
3350 misbehaving display function, rationalize it (Bug#5984). */
3351 if (it
->end_charpos
> ZV
)
3352 it
->end_charpos
= ZV
;
3353 it
->stop_charpos
= it
->end_charpos
;
3355 /* If next overlay change is in front of the current stop pos
3356 (which is IT->end_charpos), stop there. Note: value of
3357 next_overlay_change is point-max if no overlay change
3359 charpos
= IT_CHARPOS (*it
);
3360 bytepos
= IT_BYTEPOS (*it
);
3361 pos
= next_overlay_change (charpos
);
3362 if (pos
< it
->stop_charpos
)
3363 it
->stop_charpos
= pos
;
3365 /* If showing the region, we have to stop at the region
3366 start or end because the face might change there. */
3367 if (it
->region_beg_charpos
> 0)
3369 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
3370 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
3371 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
3372 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
3375 /* Set up variables for computing the stop position from text
3376 property changes. */
3377 XSETBUFFER (object
, current_buffer
);
3378 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
3381 /* Get the interval containing IT's position. Value is a null
3382 interval if there isn't such an interval. */
3383 position
= make_number (charpos
);
3384 iv
= validate_interval_range (object
, &position
, &position
, 0);
3387 Lisp_Object values_here
[LAST_PROP_IDX
];
3390 /* Get properties here. */
3391 for (p
= it_props
; p
->handler
; ++p
)
3392 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3394 /* Look for an interval following iv that has different
3396 for (next_iv
= next_interval (iv
);
3399 || XFASTINT (limit
) > next_iv
->position
));
3400 next_iv
= next_interval (next_iv
))
3402 for (p
= it_props
; p
->handler
; ++p
)
3404 Lisp_Object new_value
;
3406 new_value
= textget (next_iv
->plist
, *p
->name
);
3407 if (!EQ (values_here
[p
->idx
], new_value
))
3417 if (INTEGERP (limit
)
3418 && next_iv
->position
>= XFASTINT (limit
))
3419 /* No text property change up to limit. */
3420 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3422 /* Text properties change in next_iv. */
3423 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3427 if (it
->cmp_it
.id
< 0)
3429 ptrdiff_t stoppos
= it
->end_charpos
;
3431 if (it
->bidi_p
&& it
->bidi_it
.scan_dir
< 0)
3433 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
,
3434 stoppos
, it
->string
);
3437 eassert (STRINGP (it
->string
)
3438 || (it
->stop_charpos
>= BEGV
3439 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3443 /* Return the position of the next overlay change after POS in
3444 current_buffer. Value is point-max if no overlay change
3445 follows. This is like `next-overlay-change' but doesn't use
3449 next_overlay_change (ptrdiff_t pos
)
3451 ptrdiff_t i
, noverlays
;
3453 Lisp_Object
*overlays
;
3455 /* Get all overlays at the given position. */
3456 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3458 /* If any of these overlays ends before endpos,
3459 use its ending point instead. */
3460 for (i
= 0; i
< noverlays
; ++i
)
3465 oend
= OVERLAY_END (overlays
[i
]);
3466 oendpos
= OVERLAY_POSITION (oend
);
3467 endpos
= min (endpos
, oendpos
);
3473 /* How many characters forward to search for a display property or
3474 display string. Searching too far forward makes the bidi display
3475 sluggish, especially in small windows. */
3476 #define MAX_DISP_SCAN 250
3478 /* Return the character position of a display string at or after
3479 position specified by POSITION. If no display string exists at or
3480 after POSITION, return ZV. A display string is either an overlay
3481 with `display' property whose value is a string, or a `display'
3482 text property whose value is a string. STRING is data about the
3483 string to iterate; if STRING->lstring is nil, we are iterating a
3484 buffer. FRAME_WINDOW_P is non-zero when we are displaying a window
3485 on a GUI frame. DISP_PROP is set to zero if we searched
3486 MAX_DISP_SCAN characters forward without finding any display
3487 strings, non-zero otherwise. It is set to 2 if the display string
3488 uses any kind of `(space ...)' spec that will produce a stretch of
3489 white space in the text area. */
3491 compute_display_string_pos (struct text_pos
*position
,
3492 struct bidi_string_data
*string
,
3493 int frame_window_p
, int *disp_prop
)
3495 /* OBJECT = nil means current buffer. */
3496 Lisp_Object object
=
3497 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3498 Lisp_Object pos
, spec
, limpos
;
3499 int string_p
= (string
&& (STRINGP (string
->lstring
) || string
->s
));
3500 ptrdiff_t eob
= string_p
? string
->schars
: ZV
;
3501 ptrdiff_t begb
= string_p
? 0 : BEGV
;
3502 ptrdiff_t bufpos
, charpos
= CHARPOS (*position
);
3504 (charpos
< eob
- MAX_DISP_SCAN
) ? charpos
+ MAX_DISP_SCAN
: eob
;
3505 struct text_pos tpos
;
3511 /* We don't support display properties whose values are strings
3512 that have display string properties. */
3513 || string
->from_disp_str
3514 /* C strings cannot have display properties. */
3515 || (string
->s
&& !STRINGP (object
)))
3521 /* If the character at CHARPOS is where the display string begins,
3523 pos
= make_number (charpos
);
3524 if (STRINGP (object
))
3525 bufpos
= string
->bufpos
;
3529 if (!NILP (spec
= Fget_char_property (pos
, Qdisplay
, object
))
3531 || !EQ (Fget_char_property (make_number (charpos
- 1), Qdisplay
,
3534 && (rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
, bufpos
,
3542 /* Look forward for the first character with a `display' property
3543 that will replace the underlying text when displayed. */
3544 limpos
= make_number (lim
);
3546 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, limpos
);
3547 CHARPOS (tpos
) = XFASTINT (pos
);
3548 if (CHARPOS (tpos
) >= lim
)
3553 if (STRINGP (object
))
3554 BYTEPOS (tpos
) = string_char_to_byte (object
, CHARPOS (tpos
));
3556 BYTEPOS (tpos
) = CHAR_TO_BYTE (CHARPOS (tpos
));
3557 spec
= Fget_char_property (pos
, Qdisplay
, object
);
3558 if (!STRINGP (object
))
3559 bufpos
= CHARPOS (tpos
);
3560 } while (NILP (spec
)
3561 || !(rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
,
3562 bufpos
, frame_window_p
)));
3566 return CHARPOS (tpos
);
3569 /* Return the character position of the end of the display string that
3570 started at CHARPOS. If there's no display string at CHARPOS,
3571 return -1. A display string is either an overlay with `display'
3572 property whose value is a string or a `display' text property whose
3573 value is a string. */
3575 compute_display_string_end (ptrdiff_t charpos
, struct bidi_string_data
*string
)
3577 /* OBJECT = nil means current buffer. */
3578 Lisp_Object object
=
3579 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3580 Lisp_Object pos
= make_number (charpos
);
3582 (STRINGP (object
) || (string
&& string
->s
)) ? string
->schars
: ZV
;
3584 if (charpos
>= eob
|| (string
->s
&& !STRINGP (object
)))
3587 /* It could happen that the display property or overlay was removed
3588 since we found it in compute_display_string_pos above. One way
3589 this can happen is if JIT font-lock was called (through
3590 handle_fontified_prop), and jit-lock-functions remove text
3591 properties or overlays from the portion of buffer that includes
3592 CHARPOS. Muse mode is known to do that, for example. In this
3593 case, we return -1 to the caller, to signal that no display
3594 string is actually present at CHARPOS. See bidi_fetch_char for
3595 how this is handled.
3597 An alternative would be to never look for display properties past
3598 it->stop_charpos. But neither compute_display_string_pos nor
3599 bidi_fetch_char that calls it know or care where the next
3601 if (NILP (Fget_char_property (pos
, Qdisplay
, object
)))
3604 /* Look forward for the first character where the `display' property
3606 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3608 return XFASTINT (pos
);
3613 /***********************************************************************
3615 ***********************************************************************/
3617 /* Handle changes in the `fontified' property of the current buffer by
3618 calling hook functions from Qfontification_functions to fontify
3621 static enum prop_handled
3622 handle_fontified_prop (struct it
*it
)
3624 Lisp_Object prop
, pos
;
3625 enum prop_handled handled
= HANDLED_NORMALLY
;
3627 if (!NILP (Vmemory_full
))
3630 /* Get the value of the `fontified' property at IT's current buffer
3631 position. (The `fontified' property doesn't have a special
3632 meaning in strings.) If the value is nil, call functions from
3633 Qfontification_functions. */
3634 if (!STRINGP (it
->string
)
3636 && !NILP (Vfontification_functions
)
3637 && !NILP (Vrun_hooks
)
3638 && (pos
= make_number (IT_CHARPOS (*it
)),
3639 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3640 /* Ignore the special cased nil value always present at EOB since
3641 no amount of fontifying will be able to change it. */
3642 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3644 ptrdiff_t count
= SPECPDL_INDEX ();
3646 struct buffer
*obuf
= current_buffer
;
3647 int begv
= BEGV
, zv
= ZV
;
3648 int old_clip_changed
= current_buffer
->clip_changed
;
3650 val
= Vfontification_functions
;
3651 specbind (Qfontification_functions
, Qnil
);
3653 eassert (it
->end_charpos
== ZV
);
3655 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3656 safe_call1 (val
, pos
);
3659 Lisp_Object fns
, fn
;
3660 struct gcpro gcpro1
, gcpro2
;
3665 for (; CONSP (val
); val
= XCDR (val
))
3671 /* A value of t indicates this hook has a local
3672 binding; it means to run the global binding too.
3673 In a global value, t should not occur. If it
3674 does, we must ignore it to avoid an endless
3676 for (fns
= Fdefault_value (Qfontification_functions
);
3682 safe_call1 (fn
, pos
);
3686 safe_call1 (fn
, pos
);
3692 unbind_to (count
, Qnil
);
3694 /* Fontification functions routinely call `save-restriction'.
3695 Normally, this tags clip_changed, which can confuse redisplay
3696 (see discussion in Bug#6671). Since we don't perform any
3697 special handling of fontification changes in the case where
3698 `save-restriction' isn't called, there's no point doing so in
3699 this case either. So, if the buffer's restrictions are
3700 actually left unchanged, reset clip_changed. */
3701 if (obuf
== current_buffer
)
3703 if (begv
== BEGV
&& zv
== ZV
)
3704 current_buffer
->clip_changed
= old_clip_changed
;
3706 /* There isn't much we can reasonably do to protect against
3707 misbehaving fontification, but here's a fig leaf. */
3708 else if (BUFFER_LIVE_P (obuf
))
3709 set_buffer_internal_1 (obuf
);
3711 /* The fontification code may have added/removed text.
3712 It could do even a lot worse, but let's at least protect against
3713 the most obvious case where only the text past `pos' gets changed',
3714 as is/was done in grep.el where some escapes sequences are turned
3715 into face properties (bug#7876). */
3716 it
->end_charpos
= ZV
;
3718 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3719 something. This avoids an endless loop if they failed to
3720 fontify the text for which reason ever. */
3721 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3722 handled
= HANDLED_RECOMPUTE_PROPS
;
3730 /***********************************************************************
3732 ***********************************************************************/
3734 /* Set up iterator IT from face properties at its current position.
3735 Called from handle_stop. */
3737 static enum prop_handled
3738 handle_face_prop (struct it
*it
)
3741 ptrdiff_t next_stop
;
3743 if (!STRINGP (it
->string
))
3746 = face_at_buffer_position (it
->w
,
3748 it
->region_beg_charpos
,
3749 it
->region_end_charpos
,
3752 + TEXT_PROP_DISTANCE_LIMIT
),
3753 0, it
->base_face_id
);
3755 /* Is this a start of a run of characters with box face?
3756 Caveat: this can be called for a freshly initialized
3757 iterator; face_id is -1 in this case. We know that the new
3758 face will not change until limit, i.e. if the new face has a
3759 box, all characters up to limit will have one. But, as
3760 usual, we don't know whether limit is really the end. */
3761 if (new_face_id
!= it
->face_id
)
3763 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3765 /* If new face has a box but old face has not, this is
3766 the start of a run of characters with box, i.e. it has
3767 a shadow on the left side. The value of face_id of the
3768 iterator will be -1 if this is the initial call that gets
3769 the face. In this case, we have to look in front of IT's
3770 position and see whether there is a face != new_face_id. */
3771 it
->start_of_box_run_p
3772 = (new_face
->box
!= FACE_NO_BOX
3773 && (it
->face_id
>= 0
3774 || IT_CHARPOS (*it
) == BEG
3775 || new_face_id
!= face_before_it_pos (it
)));
3776 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3784 Lisp_Object from_overlay
3785 = (it
->current
.overlay_string_index
>= 0
3786 ? it
->string_overlays
[it
->current
.overlay_string_index
3787 % OVERLAY_STRING_CHUNK_SIZE
]
3790 /* See if we got to this string directly or indirectly from
3791 an overlay property. That includes the before-string or
3792 after-string of an overlay, strings in display properties
3793 provided by an overlay, their text properties, etc.
3795 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3796 if (! NILP (from_overlay
))
3797 for (i
= it
->sp
- 1; i
>= 0; i
--)
3799 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3801 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
3802 % OVERLAY_STRING_CHUNK_SIZE
];
3803 else if (! NILP (it
->stack
[i
].from_overlay
))
3804 from_overlay
= it
->stack
[i
].from_overlay
;
3806 if (!NILP (from_overlay
))
3810 if (! NILP (from_overlay
))
3812 bufpos
= IT_CHARPOS (*it
);
3813 /* For a string from an overlay, the base face depends
3814 only on text properties and ignores overlays. */
3816 = face_for_overlay_string (it
->w
,
3818 it
->region_beg_charpos
,
3819 it
->region_end_charpos
,
3822 + TEXT_PROP_DISTANCE_LIMIT
),
3830 /* For strings from a `display' property, use the face at
3831 IT's current buffer position as the base face to merge
3832 with, so that overlay strings appear in the same face as
3833 surrounding text, unless they specify their own
3835 base_face_id
= it
->string_from_prefix_prop_p
3837 : underlying_face_id (it
);
3840 new_face_id
= face_at_string_position (it
->w
,
3842 IT_STRING_CHARPOS (*it
),
3844 it
->region_beg_charpos
,
3845 it
->region_end_charpos
,
3849 /* Is this a start of a run of characters with box? Caveat:
3850 this can be called for a freshly allocated iterator; face_id
3851 is -1 is this case. We know that the new face will not
3852 change until the next check pos, i.e. if the new face has a
3853 box, all characters up to that position will have a
3854 box. But, as usual, we don't know whether that position
3855 is really the end. */
3856 if (new_face_id
!= it
->face_id
)
3858 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3859 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3861 /* If new face has a box but old face hasn't, this is the
3862 start of a run of characters with box, i.e. it has a
3863 shadow on the left side. */
3864 it
->start_of_box_run_p
3865 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
3866 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3870 it
->face_id
= new_face_id
;
3871 return HANDLED_NORMALLY
;
3875 /* Return the ID of the face ``underlying'' IT's current position,
3876 which is in a string. If the iterator is associated with a
3877 buffer, return the face at IT's current buffer position.
3878 Otherwise, use the iterator's base_face_id. */
3881 underlying_face_id (struct it
*it
)
3883 int face_id
= it
->base_face_id
, i
;
3885 eassert (STRINGP (it
->string
));
3887 for (i
= it
->sp
- 1; i
>= 0; --i
)
3888 if (NILP (it
->stack
[i
].string
))
3889 face_id
= it
->stack
[i
].face_id
;
3895 /* Compute the face one character before or after the current position
3896 of IT, in the visual order. BEFORE_P non-zero means get the face
3897 in front (to the left in L2R paragraphs, to the right in R2L
3898 paragraphs) of IT's screen position. Value is the ID of the face. */
3901 face_before_or_after_it_pos (struct it
*it
, int before_p
)
3904 ptrdiff_t next_check_charpos
;
3906 void *it_copy_data
= NULL
;
3908 eassert (it
->s
== NULL
);
3910 if (STRINGP (it
->string
))
3912 ptrdiff_t bufpos
, charpos
;
3915 /* No face change past the end of the string (for the case
3916 we are padding with spaces). No face change before the
3918 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
3919 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
3924 /* Set charpos to the position before or after IT's current
3925 position, in the logical order, which in the non-bidi
3926 case is the same as the visual order. */
3928 charpos
= IT_STRING_CHARPOS (*it
) - 1;
3929 else if (it
->what
== IT_COMPOSITION
)
3930 /* For composition, we must check the character after the
3932 charpos
= IT_STRING_CHARPOS (*it
) + it
->cmp_it
.nchars
;
3934 charpos
= IT_STRING_CHARPOS (*it
) + 1;
3940 /* With bidi iteration, the character before the current
3941 in the visual order cannot be found by simple
3942 iteration, because "reverse" reordering is not
3943 supported. Instead, we need to use the move_it_*
3944 family of functions. */
3945 /* Ignore face changes before the first visible
3946 character on this display line. */
3947 if (it
->current_x
<= it
->first_visible_x
)
3949 SAVE_IT (it_copy
, *it
, it_copy_data
);
3950 /* Implementation note: Since move_it_in_display_line
3951 works in the iterator geometry, and thinks the first
3952 character is always the leftmost, even in R2L lines,
3953 we don't need to distinguish between the R2L and L2R
3955 move_it_in_display_line (&it_copy
, SCHARS (it_copy
.string
),
3956 it_copy
.current_x
- 1, MOVE_TO_X
);
3957 charpos
= IT_STRING_CHARPOS (it_copy
);
3958 RESTORE_IT (it
, it
, it_copy_data
);
3962 /* Set charpos to the string position of the character
3963 that comes after IT's current position in the visual
3965 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
3969 bidi_move_to_visually_next (&it_copy
.bidi_it
);
3971 charpos
= it_copy
.bidi_it
.charpos
;
3974 eassert (0 <= charpos
&& charpos
<= SCHARS (it
->string
));
3976 if (it
->current
.overlay_string_index
>= 0)
3977 bufpos
= IT_CHARPOS (*it
);
3981 base_face_id
= underlying_face_id (it
);
3983 /* Get the face for ASCII, or unibyte. */
3984 face_id
= face_at_string_position (it
->w
,
3988 it
->region_beg_charpos
,
3989 it
->region_end_charpos
,
3990 &next_check_charpos
,
3993 /* Correct the face for charsets different from ASCII. Do it
3994 for the multibyte case only. The face returned above is
3995 suitable for unibyte text if IT->string is unibyte. */
3996 if (STRING_MULTIBYTE (it
->string
))
3998 struct text_pos pos1
= string_pos (charpos
, it
->string
);
3999 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos1
);
4001 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
4003 c
= string_char_and_length (p
, &len
);
4004 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, charpos
, it
->string
);
4009 struct text_pos pos
;
4011 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
4012 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
4015 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
4016 pos
= it
->current
.pos
;
4021 DEC_TEXT_POS (pos
, it
->multibyte_p
);
4024 if (it
->what
== IT_COMPOSITION
)
4026 /* For composition, we must check the position after
4028 pos
.charpos
+= it
->cmp_it
.nchars
;
4029 pos
.bytepos
+= it
->len
;
4032 INC_TEXT_POS (pos
, it
->multibyte_p
);
4039 /* With bidi iteration, the character before the current
4040 in the visual order cannot be found by simple
4041 iteration, because "reverse" reordering is not
4042 supported. Instead, we need to use the move_it_*
4043 family of functions. */
4044 /* Ignore face changes before the first visible
4045 character on this display line. */
4046 if (it
->current_x
<= it
->first_visible_x
)
4048 SAVE_IT (it_copy
, *it
, it_copy_data
);
4049 /* Implementation note: Since move_it_in_display_line
4050 works in the iterator geometry, and thinks the first
4051 character is always the leftmost, even in R2L lines,
4052 we don't need to distinguish between the R2L and L2R
4054 move_it_in_display_line (&it_copy
, ZV
,
4055 it_copy
.current_x
- 1, MOVE_TO_X
);
4056 pos
= it_copy
.current
.pos
;
4057 RESTORE_IT (it
, it
, it_copy_data
);
4061 /* Set charpos to the buffer position of the character
4062 that comes after IT's current position in the visual
4064 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
4068 bidi_move_to_visually_next (&it_copy
.bidi_it
);
4071 it_copy
.bidi_it
.charpos
, it_copy
.bidi_it
.bytepos
);
4074 eassert (BEGV
<= CHARPOS (pos
) && CHARPOS (pos
) <= ZV
);
4076 /* Determine face for CHARSET_ASCII, or unibyte. */
4077 face_id
= face_at_buffer_position (it
->w
,
4079 it
->region_beg_charpos
,
4080 it
->region_end_charpos
,
4081 &next_check_charpos
,
4084 /* Correct the face for charsets different from ASCII. Do it
4085 for the multibyte case only. The face returned above is
4086 suitable for unibyte text if current_buffer is unibyte. */
4087 if (it
->multibyte_p
)
4089 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
4090 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
4091 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
4100 /***********************************************************************
4102 ***********************************************************************/
4104 /* Set up iterator IT from invisible properties at its current
4105 position. Called from handle_stop. */
4107 static enum prop_handled
4108 handle_invisible_prop (struct it
*it
)
4110 enum prop_handled handled
= HANDLED_NORMALLY
;
4114 if (STRINGP (it
->string
))
4116 Lisp_Object end_charpos
, limit
, charpos
;
4118 /* Get the value of the invisible text property at the
4119 current position. Value will be nil if there is no such
4121 charpos
= make_number (IT_STRING_CHARPOS (*it
));
4122 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
4123 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4125 if (invis_p
&& IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
4127 /* Record whether we have to display an ellipsis for the
4129 int display_ellipsis_p
= (invis_p
== 2);
4130 ptrdiff_t len
, endpos
;
4132 handled
= HANDLED_RECOMPUTE_PROPS
;
4134 /* Get the position at which the next visible text can be
4135 found in IT->string, if any. */
4136 endpos
= len
= SCHARS (it
->string
);
4137 XSETINT (limit
, len
);
4140 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
4142 if (INTEGERP (end_charpos
))
4144 endpos
= XFASTINT (end_charpos
);
4145 prop
= Fget_text_property (end_charpos
, Qinvisible
, it
->string
);
4146 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4148 display_ellipsis_p
= 1;
4151 while (invis_p
&& endpos
< len
);
4153 if (display_ellipsis_p
)
4158 /* Text at END_CHARPOS is visible. Move IT there. */
4159 struct text_pos old
;
4162 old
= it
->current
.string_pos
;
4163 oldpos
= CHARPOS (old
);
4166 if (it
->bidi_it
.first_elt
4167 && it
->bidi_it
.charpos
< SCHARS (it
->string
))
4168 bidi_paragraph_init (it
->paragraph_embedding
,
4170 /* Bidi-iterate out of the invisible text. */
4173 bidi_move_to_visually_next (&it
->bidi_it
);
4175 while (oldpos
<= it
->bidi_it
.charpos
4176 && it
->bidi_it
.charpos
< endpos
);
4178 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4179 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4180 if (IT_CHARPOS (*it
) >= endpos
)
4181 it
->prev_stop
= endpos
;
4185 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
4186 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
4191 /* The rest of the string is invisible. If this is an
4192 overlay string, proceed with the next overlay string
4193 or whatever comes and return a character from there. */
4194 if (it
->current
.overlay_string_index
>= 0
4195 && !display_ellipsis_p
)
4197 next_overlay_string (it
);
4198 /* Don't check for overlay strings when we just
4199 finished processing them. */
4200 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
4204 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
4205 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
4212 ptrdiff_t newpos
, next_stop
, start_charpos
, tem
;
4213 Lisp_Object pos
, overlay
;
4215 /* First of all, is there invisible text at this position? */
4216 tem
= start_charpos
= IT_CHARPOS (*it
);
4217 pos
= make_number (tem
);
4218 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
4220 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4222 /* If we are on invisible text, skip over it. */
4223 if (invis_p
&& start_charpos
< it
->end_charpos
)
4225 /* Record whether we have to display an ellipsis for the
4227 int display_ellipsis_p
= invis_p
== 2;
4229 handled
= HANDLED_RECOMPUTE_PROPS
;
4231 /* Loop skipping over invisible text. The loop is left at
4232 ZV or with IT on the first char being visible again. */
4235 /* Try to skip some invisible text. Return value is the
4236 position reached which can be equal to where we start
4237 if there is nothing invisible there. This skips both
4238 over invisible text properties and overlays with
4239 invisible property. */
4240 newpos
= skip_invisible (tem
, &next_stop
, ZV
, it
->window
);
4242 /* If we skipped nothing at all we weren't at invisible
4243 text in the first place. If everything to the end of
4244 the buffer was skipped, end the loop. */
4245 if (newpos
== tem
|| newpos
>= ZV
)
4249 /* We skipped some characters but not necessarily
4250 all there are. Check if we ended up on visible
4251 text. Fget_char_property returns the property of
4252 the char before the given position, i.e. if we
4253 get invis_p = 0, this means that the char at
4254 newpos is visible. */
4255 pos
= make_number (newpos
);
4256 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
4257 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4260 /* If we ended up on invisible text, proceed to
4261 skip starting with next_stop. */
4265 /* If there are adjacent invisible texts, don't lose the
4266 second one's ellipsis. */
4268 display_ellipsis_p
= 1;
4272 /* The position newpos is now either ZV or on visible text. */
4275 ptrdiff_t bpos
= CHAR_TO_BYTE (newpos
);
4277 bpos
== ZV_BYTE
|| FETCH_BYTE (bpos
) == '\n';
4279 newpos
<= BEGV
|| FETCH_BYTE (bpos
- 1) == '\n';
4281 /* If the invisible text ends on a newline or on a
4282 character after a newline, we can avoid the costly,
4283 character by character, bidi iteration to NEWPOS, and
4284 instead simply reseat the iterator there. That's
4285 because all bidi reordering information is tossed at
4286 the newline. This is a big win for modes that hide
4287 complete lines, like Outline, Org, etc. */
4288 if (on_newline
|| after_newline
)
4290 struct text_pos tpos
;
4291 bidi_dir_t pdir
= it
->bidi_it
.paragraph_dir
;
4293 SET_TEXT_POS (tpos
, newpos
, bpos
);
4294 reseat_1 (it
, tpos
, 0);
4295 /* If we reseat on a newline/ZV, we need to prep the
4296 bidi iterator for advancing to the next character
4297 after the newline/EOB, keeping the current paragraph
4298 direction (so that PRODUCE_GLYPHS does TRT wrt
4299 prepending/appending glyphs to a glyph row). */
4302 it
->bidi_it
.first_elt
= 0;
4303 it
->bidi_it
.paragraph_dir
= pdir
;
4304 it
->bidi_it
.ch
= (bpos
== ZV_BYTE
) ? -1 : '\n';
4305 it
->bidi_it
.nchars
= 1;
4306 it
->bidi_it
.ch_len
= 1;
4309 else /* Must use the slow method. */
4311 /* With bidi iteration, the region of invisible text
4312 could start and/or end in the middle of a
4313 non-base embedding level. Therefore, we need to
4314 skip invisible text using the bidi iterator,
4315 starting at IT's current position, until we find
4316 ourselves outside of the invisible text.
4317 Skipping invisible text _after_ bidi iteration
4318 avoids affecting the visual order of the
4319 displayed text when invisible properties are
4320 added or removed. */
4321 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
4323 /* If we were `reseat'ed to a new paragraph,
4324 determine the paragraph base direction. We
4325 need to do it now because
4326 next_element_from_buffer may not have a
4327 chance to do it, if we are going to skip any
4328 text at the beginning, which resets the
4330 bidi_paragraph_init (it
->paragraph_embedding
,
4335 bidi_move_to_visually_next (&it
->bidi_it
);
4337 while (it
->stop_charpos
<= it
->bidi_it
.charpos
4338 && it
->bidi_it
.charpos
< newpos
);
4339 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4340 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4341 /* If we overstepped NEWPOS, record its position in
4342 the iterator, so that we skip invisible text if
4343 later the bidi iteration lands us in the
4344 invisible region again. */
4345 if (IT_CHARPOS (*it
) >= newpos
)
4346 it
->prev_stop
= newpos
;
4351 IT_CHARPOS (*it
) = newpos
;
4352 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
4355 /* If there are before-strings at the start of invisible
4356 text, and the text is invisible because of a text
4357 property, arrange to show before-strings because 20.x did
4358 it that way. (If the text is invisible because of an
4359 overlay property instead of a text property, this is
4360 already handled in the overlay code.) */
4362 && get_overlay_strings (it
, it
->stop_charpos
))
4364 handled
= HANDLED_RECOMPUTE_PROPS
;
4365 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
4367 else if (display_ellipsis_p
)
4369 /* Make sure that the glyphs of the ellipsis will get
4370 correct `charpos' values. If we would not update
4371 it->position here, the glyphs would belong to the
4372 last visible character _before_ the invisible
4373 text, which confuses `set_cursor_from_row'.
4375 We use the last invisible position instead of the
4376 first because this way the cursor is always drawn on
4377 the first "." of the ellipsis, whenever PT is inside
4378 the invisible text. Otherwise the cursor would be
4379 placed _after_ the ellipsis when the point is after the
4380 first invisible character. */
4381 if (!STRINGP (it
->object
))
4383 it
->position
.charpos
= newpos
- 1;
4384 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
4387 /* Let the ellipsis display before
4388 considering any properties of the following char.
4389 Fixes jasonr@gnu.org 01 Oct 07 bug. */
4390 handled
= HANDLED_RETURN
;
4399 /* Make iterator IT return `...' next.
4400 Replaces LEN characters from buffer. */
4403 setup_for_ellipsis (struct it
*it
, int len
)
4405 /* Use the display table definition for `...'. Invalid glyphs
4406 will be handled by the method returning elements from dpvec. */
4407 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4409 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4410 it
->dpvec
= v
->contents
;
4411 it
->dpend
= v
->contents
+ v
->header
.size
;
4415 /* Default `...'. */
4416 it
->dpvec
= default_invis_vector
;
4417 it
->dpend
= default_invis_vector
+ 3;
4420 it
->dpvec_char_len
= len
;
4421 it
->current
.dpvec_index
= 0;
4422 it
->dpvec_face_id
= -1;
4424 /* Remember the current face id in case glyphs specify faces.
4425 IT's face is restored in set_iterator_to_next.
4426 saved_face_id was set to preceding char's face in handle_stop. */
4427 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
4428 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
4430 it
->method
= GET_FROM_DISPLAY_VECTOR
;
4436 /***********************************************************************
4438 ***********************************************************************/
4440 /* Set up iterator IT from `display' property at its current position.
4441 Called from handle_stop.
4442 We return HANDLED_RETURN if some part of the display property
4443 overrides the display of the buffer text itself.
4444 Otherwise we return HANDLED_NORMALLY. */
4446 static enum prop_handled
4447 handle_display_prop (struct it
*it
)
4449 Lisp_Object propval
, object
, overlay
;
4450 struct text_pos
*position
;
4452 /* Nonzero if some property replaces the display of the text itself. */
4453 int display_replaced_p
= 0;
4455 if (STRINGP (it
->string
))
4457 object
= it
->string
;
4458 position
= &it
->current
.string_pos
;
4459 bufpos
= CHARPOS (it
->current
.pos
);
4463 XSETWINDOW (object
, it
->w
);
4464 position
= &it
->current
.pos
;
4465 bufpos
= CHARPOS (*position
);
4468 /* Reset those iterator values set from display property values. */
4469 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
4470 it
->space_width
= Qnil
;
4471 it
->font_height
= Qnil
;
4474 /* We don't support recursive `display' properties, i.e. string
4475 values that have a string `display' property, that have a string
4476 `display' property etc. */
4477 if (!it
->string_from_display_prop_p
)
4478 it
->area
= TEXT_AREA
;
4480 propval
= get_char_property_and_overlay (make_number (position
->charpos
),
4481 Qdisplay
, object
, &overlay
);
4483 return HANDLED_NORMALLY
;
4484 /* Now OVERLAY is the overlay that gave us this property, or nil
4485 if it was a text property. */
4487 if (!STRINGP (it
->string
))
4488 object
= it
->w
->buffer
;
4490 display_replaced_p
= handle_display_spec (it
, propval
, object
, overlay
,
4492 FRAME_WINDOW_P (it
->f
));
4494 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
4497 /* Subroutine of handle_display_prop. Returns non-zero if the display
4498 specification in SPEC is a replacing specification, i.e. it would
4499 replace the text covered by `display' property with something else,
4500 such as an image or a display string. If SPEC includes any kind or
4501 `(space ...) specification, the value is 2; this is used by
4502 compute_display_string_pos, which see.
4504 See handle_single_display_spec for documentation of arguments.
4505 frame_window_p is non-zero if the window being redisplayed is on a
4506 GUI frame; this argument is used only if IT is NULL, see below.
4508 IT can be NULL, if this is called by the bidi reordering code
4509 through compute_display_string_pos, which see. In that case, this
4510 function only examines SPEC, but does not otherwise "handle" it, in
4511 the sense that it doesn't set up members of IT from the display
4514 handle_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4515 Lisp_Object overlay
, struct text_pos
*position
,
4516 ptrdiff_t bufpos
, int frame_window_p
)
4518 int replacing_p
= 0;
4522 /* Simple specifications. */
4523 && !EQ (XCAR (spec
), Qimage
)
4524 && !EQ (XCAR (spec
), Qspace
)
4525 && !EQ (XCAR (spec
), Qwhen
)
4526 && !EQ (XCAR (spec
), Qslice
)
4527 && !EQ (XCAR (spec
), Qspace_width
)
4528 && !EQ (XCAR (spec
), Qheight
)
4529 && !EQ (XCAR (spec
), Qraise
)
4530 /* Marginal area specifications. */
4531 && !(CONSP (XCAR (spec
)) && EQ (XCAR (XCAR (spec
)), Qmargin
))
4532 && !EQ (XCAR (spec
), Qleft_fringe
)
4533 && !EQ (XCAR (spec
), Qright_fringe
)
4534 && !NILP (XCAR (spec
)))
4536 for (; CONSP (spec
); spec
= XCDR (spec
))
4538 if ((rv
= handle_single_display_spec (it
, XCAR (spec
), object
,
4539 overlay
, position
, bufpos
,
4540 replacing_p
, frame_window_p
)))
4543 /* If some text in a string is replaced, `position' no
4544 longer points to the position of `object'. */
4545 if (!it
|| STRINGP (object
))
4550 else if (VECTORP (spec
))
4553 for (i
= 0; i
< ASIZE (spec
); ++i
)
4554 if ((rv
= handle_single_display_spec (it
, AREF (spec
, i
), object
,
4555 overlay
, position
, bufpos
,
4556 replacing_p
, frame_window_p
)))
4559 /* If some text in a string is replaced, `position' no
4560 longer points to the position of `object'. */
4561 if (!it
|| STRINGP (object
))
4567 if ((rv
= handle_single_display_spec (it
, spec
, object
, overlay
,
4568 position
, bufpos
, 0,
4576 /* Value is the position of the end of the `display' property starting
4577 at START_POS in OBJECT. */
4579 static struct text_pos
4580 display_prop_end (struct it
*it
, Lisp_Object object
, struct text_pos start_pos
)
4583 struct text_pos end_pos
;
4585 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
4586 Qdisplay
, object
, Qnil
);
4587 CHARPOS (end_pos
) = XFASTINT (end
);
4588 if (STRINGP (object
))
4589 compute_string_pos (&end_pos
, start_pos
, it
->string
);
4591 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
4597 /* Set up IT from a single `display' property specification SPEC. OBJECT
4598 is the object in which the `display' property was found. *POSITION
4599 is the position in OBJECT at which the `display' property was found.
4600 BUFPOS is the buffer position of OBJECT (different from POSITION if
4601 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
4602 previously saw a display specification which already replaced text
4603 display with something else, for example an image; we ignore such
4604 properties after the first one has been processed.
4606 OVERLAY is the overlay this `display' property came from,
4607 or nil if it was a text property.
4609 If SPEC is a `space' or `image' specification, and in some other
4610 cases too, set *POSITION to the position where the `display'
4613 If IT is NULL, only examine the property specification in SPEC, but
4614 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
4615 is intended to be displayed in a window on a GUI frame.
4617 Value is non-zero if something was found which replaces the display
4618 of buffer or string text. */
4621 handle_single_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4622 Lisp_Object overlay
, struct text_pos
*position
,
4623 ptrdiff_t bufpos
, int display_replaced_p
,
4627 Lisp_Object location
, value
;
4628 struct text_pos start_pos
= *position
;
4631 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4632 If the result is non-nil, use VALUE instead of SPEC. */
4634 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
4643 if (!NILP (form
) && !EQ (form
, Qt
))
4645 ptrdiff_t count
= SPECPDL_INDEX ();
4646 struct gcpro gcpro1
;
4648 /* Bind `object' to the object having the `display' property, a
4649 buffer or string. Bind `position' to the position in the
4650 object where the property was found, and `buffer-position'
4651 to the current position in the buffer. */
4654 XSETBUFFER (object
, current_buffer
);
4655 specbind (Qobject
, object
);
4656 specbind (Qposition
, make_number (CHARPOS (*position
)));
4657 specbind (Qbuffer_position
, make_number (bufpos
));
4659 form
= safe_eval (form
);
4661 unbind_to (count
, Qnil
);
4667 /* Handle `(height HEIGHT)' specifications. */
4669 && EQ (XCAR (spec
), Qheight
)
4670 && CONSP (XCDR (spec
)))
4674 if (!FRAME_WINDOW_P (it
->f
))
4677 it
->font_height
= XCAR (XCDR (spec
));
4678 if (!NILP (it
->font_height
))
4680 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4681 int new_height
= -1;
4683 if (CONSP (it
->font_height
)
4684 && (EQ (XCAR (it
->font_height
), Qplus
)
4685 || EQ (XCAR (it
->font_height
), Qminus
))
4686 && CONSP (XCDR (it
->font_height
))
4687 && RANGED_INTEGERP (0, XCAR (XCDR (it
->font_height
)), INT_MAX
))
4689 /* `(+ N)' or `(- N)' where N is an integer. */
4690 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4691 if (EQ (XCAR (it
->font_height
), Qplus
))
4693 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4695 else if (FUNCTIONP (it
->font_height
))
4697 /* Call function with current height as argument.
4698 Value is the new height. */
4700 height
= safe_call1 (it
->font_height
,
4701 face
->lface
[LFACE_HEIGHT_INDEX
]);
4702 if (NUMBERP (height
))
4703 new_height
= XFLOATINT (height
);
4705 else if (NUMBERP (it
->font_height
))
4707 /* Value is a multiple of the canonical char height. */
4710 f
= FACE_FROM_ID (it
->f
,
4711 lookup_basic_face (it
->f
, DEFAULT_FACE_ID
));
4712 new_height
= (XFLOATINT (it
->font_height
)
4713 * XINT (f
->lface
[LFACE_HEIGHT_INDEX
]));
4717 /* Evaluate IT->font_height with `height' bound to the
4718 current specified height to get the new height. */
4719 ptrdiff_t count
= SPECPDL_INDEX ();
4721 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4722 value
= safe_eval (it
->font_height
);
4723 unbind_to (count
, Qnil
);
4725 if (NUMBERP (value
))
4726 new_height
= XFLOATINT (value
);
4730 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4737 /* Handle `(space-width WIDTH)'. */
4739 && EQ (XCAR (spec
), Qspace_width
)
4740 && CONSP (XCDR (spec
)))
4744 if (!FRAME_WINDOW_P (it
->f
))
4747 value
= XCAR (XCDR (spec
));
4748 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4749 it
->space_width
= value
;
4755 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4757 && EQ (XCAR (spec
), Qslice
))
4763 if (!FRAME_WINDOW_P (it
->f
))
4766 if (tem
= XCDR (spec
), CONSP (tem
))
4768 it
->slice
.x
= XCAR (tem
);
4769 if (tem
= XCDR (tem
), CONSP (tem
))
4771 it
->slice
.y
= XCAR (tem
);
4772 if (tem
= XCDR (tem
), CONSP (tem
))
4774 it
->slice
.width
= XCAR (tem
);
4775 if (tem
= XCDR (tem
), CONSP (tem
))
4776 it
->slice
.height
= XCAR (tem
);
4785 /* Handle `(raise FACTOR)'. */
4787 && EQ (XCAR (spec
), Qraise
)
4788 && CONSP (XCDR (spec
)))
4792 if (!FRAME_WINDOW_P (it
->f
))
4795 #ifdef HAVE_WINDOW_SYSTEM
4796 value
= XCAR (XCDR (spec
));
4797 if (NUMBERP (value
))
4799 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4800 it
->voffset
= - (XFLOATINT (value
)
4801 * (FONT_HEIGHT (face
->font
)));
4803 #endif /* HAVE_WINDOW_SYSTEM */
4809 /* Don't handle the other kinds of display specifications
4810 inside a string that we got from a `display' property. */
4811 if (it
&& it
->string_from_display_prop_p
)
4814 /* Characters having this form of property are not displayed, so
4815 we have to find the end of the property. */
4818 start_pos
= *position
;
4819 *position
= display_prop_end (it
, object
, start_pos
);
4823 /* Stop the scan at that end position--we assume that all
4824 text properties change there. */
4826 it
->stop_charpos
= position
->charpos
;
4828 /* Handle `(left-fringe BITMAP [FACE])'
4829 and `(right-fringe BITMAP [FACE])'. */
4831 && (EQ (XCAR (spec
), Qleft_fringe
)
4832 || EQ (XCAR (spec
), Qright_fringe
))
4833 && CONSP (XCDR (spec
)))
4839 if (!FRAME_WINDOW_P (it
->f
))
4840 /* If we return here, POSITION has been advanced
4841 across the text with this property. */
4843 /* Synchronize the bidi iterator with POSITION. This is
4844 needed because we are not going to push the iterator
4845 on behalf of this display property, so there will be
4846 no pop_it call to do this synchronization for us. */
4849 it
->position
= *position
;
4850 iterate_out_of_display_property (it
);
4851 *position
= it
->position
;
4856 else if (!frame_window_p
)
4859 #ifdef HAVE_WINDOW_SYSTEM
4860 value
= XCAR (XCDR (spec
));
4861 if (!SYMBOLP (value
)
4862 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
4863 /* If we return here, POSITION has been advanced
4864 across the text with this property. */
4866 if (it
&& it
->bidi_p
)
4868 it
->position
= *position
;
4869 iterate_out_of_display_property (it
);
4870 *position
= it
->position
;
4877 int face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);;
4879 if (CONSP (XCDR (XCDR (spec
))))
4881 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
4882 int face_id2
= lookup_derived_face (it
->f
, face_name
,
4888 /* Save current settings of IT so that we can restore them
4889 when we are finished with the glyph property value. */
4890 push_it (it
, position
);
4892 it
->area
= TEXT_AREA
;
4893 it
->what
= IT_IMAGE
;
4894 it
->image_id
= -1; /* no image */
4895 it
->position
= start_pos
;
4896 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4897 it
->method
= GET_FROM_IMAGE
;
4898 it
->from_overlay
= Qnil
;
4899 it
->face_id
= face_id
;
4900 it
->from_disp_prop_p
= 1;
4902 /* Say that we haven't consumed the characters with
4903 `display' property yet. The call to pop_it in
4904 set_iterator_to_next will clean this up. */
4905 *position
= start_pos
;
4907 if (EQ (XCAR (spec
), Qleft_fringe
))
4909 it
->left_user_fringe_bitmap
= fringe_bitmap
;
4910 it
->left_user_fringe_face_id
= face_id
;
4914 it
->right_user_fringe_bitmap
= fringe_bitmap
;
4915 it
->right_user_fringe_face_id
= face_id
;
4918 #endif /* HAVE_WINDOW_SYSTEM */
4922 /* Prepare to handle `((margin left-margin) ...)',
4923 `((margin right-margin) ...)' and `((margin nil) ...)'
4924 prefixes for display specifications. */
4925 location
= Qunbound
;
4926 if (CONSP (spec
) && CONSP (XCAR (spec
)))
4930 value
= XCDR (spec
);
4932 value
= XCAR (value
);
4935 if (EQ (XCAR (tem
), Qmargin
)
4936 && (tem
= XCDR (tem
),
4937 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
4939 || EQ (tem
, Qleft_margin
)
4940 || EQ (tem
, Qright_margin
))))
4944 if (EQ (location
, Qunbound
))
4950 /* After this point, VALUE is the property after any
4951 margin prefix has been stripped. It must be a string,
4952 an image specification, or `(space ...)'.
4954 LOCATION specifies where to display: `left-margin',
4955 `right-margin' or nil. */
4957 valid_p
= (STRINGP (value
)
4958 #ifdef HAVE_WINDOW_SYSTEM
4959 || ((it
? FRAME_WINDOW_P (it
->f
) : frame_window_p
)
4960 && valid_image_p (value
))
4961 #endif /* not HAVE_WINDOW_SYSTEM */
4962 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
4964 if (valid_p
&& !display_replaced_p
)
4970 /* Callers need to know whether the display spec is any kind
4971 of `(space ...)' spec that is about to affect text-area
4973 if (CONSP (value
) && EQ (XCAR (value
), Qspace
) && NILP (location
))
4978 /* Save current settings of IT so that we can restore them
4979 when we are finished with the glyph property value. */
4980 push_it (it
, position
);
4981 it
->from_overlay
= overlay
;
4982 it
->from_disp_prop_p
= 1;
4984 if (NILP (location
))
4985 it
->area
= TEXT_AREA
;
4986 else if (EQ (location
, Qleft_margin
))
4987 it
->area
= LEFT_MARGIN_AREA
;
4989 it
->area
= RIGHT_MARGIN_AREA
;
4991 if (STRINGP (value
))
4994 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4995 it
->current
.overlay_string_index
= -1;
4996 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4997 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
4998 it
->method
= GET_FROM_STRING
;
4999 it
->stop_charpos
= 0;
5001 it
->base_level_stop
= 0;
5002 it
->string_from_display_prop_p
= 1;
5003 /* Say that we haven't consumed the characters with
5004 `display' property yet. The call to pop_it in
5005 set_iterator_to_next will clean this up. */
5006 if (BUFFERP (object
))
5007 *position
= start_pos
;
5009 /* Force paragraph direction to be that of the parent
5010 object. If the parent object's paragraph direction is
5011 not yet determined, default to L2R. */
5012 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5013 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5015 it
->paragraph_embedding
= L2R
;
5017 /* Set up the bidi iterator for this display string. */
5020 it
->bidi_it
.string
.lstring
= it
->string
;
5021 it
->bidi_it
.string
.s
= NULL
;
5022 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5023 it
->bidi_it
.string
.bufpos
= bufpos
;
5024 it
->bidi_it
.string
.from_disp_str
= 1;
5025 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5026 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5029 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
5031 it
->method
= GET_FROM_STRETCH
;
5033 *position
= it
->position
= start_pos
;
5034 retval
= 1 + (it
->area
== TEXT_AREA
);
5036 #ifdef HAVE_WINDOW_SYSTEM
5039 it
->what
= IT_IMAGE
;
5040 it
->image_id
= lookup_image (it
->f
, value
);
5041 it
->position
= start_pos
;
5042 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
5043 it
->method
= GET_FROM_IMAGE
;
5045 /* Say that we haven't consumed the characters with
5046 `display' property yet. The call to pop_it in
5047 set_iterator_to_next will clean this up. */
5048 *position
= start_pos
;
5050 #endif /* HAVE_WINDOW_SYSTEM */
5055 /* Invalid property or property not supported. Restore
5056 POSITION to what it was before. */
5057 *position
= start_pos
;
5061 /* Check if PROP is a display property value whose text should be
5062 treated as intangible. OVERLAY is the overlay from which PROP
5063 came, or nil if it came from a text property. CHARPOS and BYTEPOS
5064 specify the buffer position covered by PROP. */
5067 display_prop_intangible_p (Lisp_Object prop
, Lisp_Object overlay
,
5068 ptrdiff_t charpos
, ptrdiff_t bytepos
)
5070 int frame_window_p
= FRAME_WINDOW_P (XFRAME (selected_frame
));
5071 struct text_pos position
;
5073 SET_TEXT_POS (position
, charpos
, bytepos
);
5074 return handle_display_spec (NULL
, prop
, Qnil
, overlay
,
5075 &position
, charpos
, frame_window_p
);
5079 /* Return 1 if PROP is a display sub-property value containing STRING.
5081 Implementation note: this and the following function are really
5082 special cases of handle_display_spec and
5083 handle_single_display_spec, and should ideally use the same code.
5084 Until they do, these two pairs must be consistent and must be
5085 modified in sync. */
5088 single_display_spec_string_p (Lisp_Object prop
, Lisp_Object string
)
5090 if (EQ (string
, prop
))
5093 /* Skip over `when FORM'. */
5094 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
5099 /* Actually, the condition following `when' should be eval'ed,
5100 like handle_single_display_spec does, and we should return
5101 zero if it evaluates to nil. However, this function is
5102 called only when the buffer was already displayed and some
5103 glyph in the glyph matrix was found to come from a display
5104 string. Therefore, the condition was already evaluated, and
5105 the result was non-nil, otherwise the display string wouldn't
5106 have been displayed and we would have never been called for
5107 this property. Thus, we can skip the evaluation and assume
5108 its result is non-nil. */
5113 /* Skip over `margin LOCATION'. */
5114 if (EQ (XCAR (prop
), Qmargin
))
5125 return EQ (prop
, string
) || (CONSP (prop
) && EQ (XCAR (prop
), string
));
5129 /* Return 1 if STRING appears in the `display' property PROP. */
5132 display_prop_string_p (Lisp_Object prop
, Lisp_Object string
)
5135 && !EQ (XCAR (prop
), Qwhen
)
5136 && !(CONSP (XCAR (prop
)) && EQ (Qmargin
, XCAR (XCAR (prop
)))))
5138 /* A list of sub-properties. */
5139 while (CONSP (prop
))
5141 if (single_display_spec_string_p (XCAR (prop
), string
))
5146 else if (VECTORP (prop
))
5148 /* A vector of sub-properties. */
5150 for (i
= 0; i
< ASIZE (prop
); ++i
)
5151 if (single_display_spec_string_p (AREF (prop
, i
), string
))
5155 return single_display_spec_string_p (prop
, string
);
5160 /* Look for STRING in overlays and text properties in the current
5161 buffer, between character positions FROM and TO (excluding TO).
5162 BACK_P non-zero means look back (in this case, TO is supposed to be
5164 Value is the first character position where STRING was found, or
5165 zero if it wasn't found before hitting TO.
5167 This function may only use code that doesn't eval because it is
5168 called asynchronously from note_mouse_highlight. */
5171 string_buffer_position_lim (Lisp_Object string
,
5172 ptrdiff_t from
, ptrdiff_t to
, int back_p
)
5174 Lisp_Object limit
, prop
, pos
;
5177 pos
= make_number (max (from
, BEGV
));
5179 if (!back_p
) /* looking forward */
5181 limit
= make_number (min (to
, ZV
));
5182 while (!found
&& !EQ (pos
, limit
))
5184 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5185 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5188 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
,
5192 else /* looking back */
5194 limit
= make_number (max (to
, BEGV
));
5195 while (!found
&& !EQ (pos
, limit
))
5197 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5198 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5201 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
5206 return found
? XINT (pos
) : 0;
5209 /* Determine which buffer position in current buffer STRING comes from.
5210 AROUND_CHARPOS is an approximate position where it could come from.
5211 Value is the buffer position or 0 if it couldn't be determined.
5213 This function is necessary because we don't record buffer positions
5214 in glyphs generated from strings (to keep struct glyph small).
5215 This function may only use code that doesn't eval because it is
5216 called asynchronously from note_mouse_highlight. */
5219 string_buffer_position (Lisp_Object string
, ptrdiff_t around_charpos
)
5221 const int MAX_DISTANCE
= 1000;
5222 ptrdiff_t found
= string_buffer_position_lim (string
, around_charpos
,
5223 around_charpos
+ MAX_DISTANCE
,
5227 found
= string_buffer_position_lim (string
, around_charpos
,
5228 around_charpos
- MAX_DISTANCE
, 1);
5234 /***********************************************************************
5235 `composition' property
5236 ***********************************************************************/
5238 /* Set up iterator IT from `composition' property at its current
5239 position. Called from handle_stop. */
5241 static enum prop_handled
5242 handle_composition_prop (struct it
*it
)
5244 Lisp_Object prop
, string
;
5245 ptrdiff_t pos
, pos_byte
, start
, end
;
5247 if (STRINGP (it
->string
))
5251 pos
= IT_STRING_CHARPOS (*it
);
5252 pos_byte
= IT_STRING_BYTEPOS (*it
);
5253 string
= it
->string
;
5254 s
= SDATA (string
) + pos_byte
;
5255 it
->c
= STRING_CHAR (s
);
5259 pos
= IT_CHARPOS (*it
);
5260 pos_byte
= IT_BYTEPOS (*it
);
5262 it
->c
= FETCH_CHAR (pos_byte
);
5265 /* If there's a valid composition and point is not inside of the
5266 composition (in the case that the composition is from the current
5267 buffer), draw a glyph composed from the composition components. */
5268 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
5269 && COMPOSITION_VALID_P (start
, end
, prop
)
5270 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
5273 /* As we can't handle this situation (perhaps font-lock added
5274 a new composition), we just return here hoping that next
5275 redisplay will detect this composition much earlier. */
5276 return HANDLED_NORMALLY
;
5279 if (STRINGP (it
->string
))
5280 pos_byte
= string_char_to_byte (it
->string
, start
);
5282 pos_byte
= CHAR_TO_BYTE (start
);
5284 it
->cmp_it
.id
= get_composition_id (start
, pos_byte
, end
- start
,
5287 if (it
->cmp_it
.id
>= 0)
5290 it
->cmp_it
.nchars
= COMPOSITION_LENGTH (prop
);
5291 it
->cmp_it
.nglyphs
= -1;
5295 return HANDLED_NORMALLY
;
5300 /***********************************************************************
5302 ***********************************************************************/
5304 /* The following structure is used to record overlay strings for
5305 later sorting in load_overlay_strings. */
5307 struct overlay_entry
5309 Lisp_Object overlay
;
5316 /* Set up iterator IT from overlay strings at its current position.
5317 Called from handle_stop. */
5319 static enum prop_handled
5320 handle_overlay_change (struct it
*it
)
5322 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
5323 return HANDLED_RECOMPUTE_PROPS
;
5325 return HANDLED_NORMALLY
;
5329 /* Set up the next overlay string for delivery by IT, if there is an
5330 overlay string to deliver. Called by set_iterator_to_next when the
5331 end of the current overlay string is reached. If there are more
5332 overlay strings to display, IT->string and
5333 IT->current.overlay_string_index are set appropriately here.
5334 Otherwise IT->string is set to nil. */
5337 next_overlay_string (struct it
*it
)
5339 ++it
->current
.overlay_string_index
;
5340 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
5342 /* No more overlay strings. Restore IT's settings to what
5343 they were before overlay strings were processed, and
5344 continue to deliver from current_buffer. */
5346 it
->ellipsis_p
= (it
->stack
[it
->sp
- 1].display_ellipsis_p
!= 0);
5349 || (NILP (it
->string
)
5350 && it
->method
== GET_FROM_BUFFER
5351 && it
->stop_charpos
>= BEGV
5352 && it
->stop_charpos
<= it
->end_charpos
));
5353 it
->current
.overlay_string_index
= -1;
5354 it
->n_overlay_strings
= 0;
5355 it
->overlay_strings_charpos
= -1;
5356 /* If there's an empty display string on the stack, pop the
5357 stack, to resync the bidi iterator with IT's position. Such
5358 empty strings are pushed onto the stack in
5359 get_overlay_strings_1. */
5360 if (it
->sp
> 0 && STRINGP (it
->string
) && !SCHARS (it
->string
))
5363 /* If we're at the end of the buffer, record that we have
5364 processed the overlay strings there already, so that
5365 next_element_from_buffer doesn't try it again. */
5366 if (NILP (it
->string
) && IT_CHARPOS (*it
) >= it
->end_charpos
)
5367 it
->overlay_strings_at_end_processed_p
= 1;
5371 /* There are more overlay strings to process. If
5372 IT->current.overlay_string_index has advanced to a position
5373 where we must load IT->overlay_strings with more strings, do
5374 it. We must load at the IT->overlay_strings_charpos where
5375 IT->n_overlay_strings was originally computed; when invisible
5376 text is present, this might not be IT_CHARPOS (Bug#7016). */
5377 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
5379 if (it
->current
.overlay_string_index
&& i
== 0)
5380 load_overlay_strings (it
, it
->overlay_strings_charpos
);
5382 /* Initialize IT to deliver display elements from the overlay
5384 it
->string
= it
->overlay_strings
[i
];
5385 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5386 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
5387 it
->method
= GET_FROM_STRING
;
5388 it
->stop_charpos
= 0;
5389 it
->end_charpos
= SCHARS (it
->string
);
5390 if (it
->cmp_it
.stop_pos
>= 0)
5391 it
->cmp_it
.stop_pos
= 0;
5393 it
->base_level_stop
= 0;
5395 /* Set up the bidi iterator for this overlay string. */
5398 it
->bidi_it
.string
.lstring
= it
->string
;
5399 it
->bidi_it
.string
.s
= NULL
;
5400 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5401 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
5402 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5403 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5404 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5412 /* Compare two overlay_entry structures E1 and E2. Used as a
5413 comparison function for qsort in load_overlay_strings. Overlay
5414 strings for the same position are sorted so that
5416 1. All after-strings come in front of before-strings, except
5417 when they come from the same overlay.
5419 2. Within after-strings, strings are sorted so that overlay strings
5420 from overlays with higher priorities come first.
5422 2. Within before-strings, strings are sorted so that overlay
5423 strings from overlays with higher priorities come last.
5425 Value is analogous to strcmp. */
5429 compare_overlay_entries (const void *e1
, const void *e2
)
5431 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
5432 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
5435 if (entry1
->after_string_p
!= entry2
->after_string_p
)
5437 /* Let after-strings appear in front of before-strings if
5438 they come from different overlays. */
5439 if (EQ (entry1
->overlay
, entry2
->overlay
))
5440 result
= entry1
->after_string_p
? 1 : -1;
5442 result
= entry1
->after_string_p
? -1 : 1;
5444 else if (entry1
->priority
!= entry2
->priority
)
5446 if (entry1
->after_string_p
)
5447 /* After-strings sorted in order of decreasing priority. */
5448 result
= entry2
->priority
< entry1
->priority
? -1 : 1;
5450 /* Before-strings sorted in order of increasing priority. */
5451 result
= entry1
->priority
< entry2
->priority
? -1 : 1;
5460 /* Load the vector IT->overlay_strings with overlay strings from IT's
5461 current buffer position, or from CHARPOS if that is > 0. Set
5462 IT->n_overlays to the total number of overlay strings found.
5464 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
5465 a time. On entry into load_overlay_strings,
5466 IT->current.overlay_string_index gives the number of overlay
5467 strings that have already been loaded by previous calls to this
5470 IT->add_overlay_start contains an additional overlay start
5471 position to consider for taking overlay strings from, if non-zero.
5472 This position comes into play when the overlay has an `invisible'
5473 property, and both before and after-strings. When we've skipped to
5474 the end of the overlay, because of its `invisible' property, we
5475 nevertheless want its before-string to appear.
5476 IT->add_overlay_start will contain the overlay start position
5479 Overlay strings are sorted so that after-string strings come in
5480 front of before-string strings. Within before and after-strings,
5481 strings are sorted by overlay priority. See also function
5482 compare_overlay_entries. */
5485 load_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5487 Lisp_Object overlay
, window
, str
, invisible
;
5488 struct Lisp_Overlay
*ov
;
5489 ptrdiff_t start
, end
;
5490 ptrdiff_t size
= 20;
5491 ptrdiff_t n
= 0, i
, j
;
5493 struct overlay_entry
*entries
= alloca (size
* sizeof *entries
);
5497 charpos
= IT_CHARPOS (*it
);
5499 /* Append the overlay string STRING of overlay OVERLAY to vector
5500 `entries' which has size `size' and currently contains `n'
5501 elements. AFTER_P non-zero means STRING is an after-string of
5503 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5506 Lisp_Object priority; \
5510 struct overlay_entry *old = entries; \
5511 SAFE_NALLOCA (entries, 2, size); \
5512 memcpy (entries, old, size * sizeof *entries); \
5516 entries[n].string = (STRING); \
5517 entries[n].overlay = (OVERLAY); \
5518 priority = Foverlay_get ((OVERLAY), Qpriority); \
5519 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5520 entries[n].after_string_p = (AFTER_P); \
5525 /* Process overlay before the overlay center. */
5526 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
5528 XSETMISC (overlay
, ov
);
5529 eassert (OVERLAYP (overlay
));
5530 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5531 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5536 /* Skip this overlay if it doesn't start or end at IT's current
5538 if (end
!= charpos
&& start
!= charpos
)
5541 /* Skip this overlay if it doesn't apply to IT->w. */
5542 window
= Foverlay_get (overlay
, Qwindow
);
5543 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5546 /* If the text ``under'' the overlay is invisible, both before-
5547 and after-strings from this overlay are visible; start and
5548 end position are indistinguishable. */
5549 invisible
= Foverlay_get (overlay
, Qinvisible
);
5550 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5552 /* If overlay has a non-empty before-string, record it. */
5553 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5554 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5556 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5558 /* If overlay has a non-empty after-string, record it. */
5559 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5560 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5562 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5565 /* Process overlays after the overlay center. */
5566 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
5568 XSETMISC (overlay
, ov
);
5569 eassert (OVERLAYP (overlay
));
5570 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5571 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5573 if (start
> charpos
)
5576 /* Skip this overlay if it doesn't start or end at IT's current
5578 if (end
!= charpos
&& start
!= charpos
)
5581 /* Skip this overlay if it doesn't apply to IT->w. */
5582 window
= Foverlay_get (overlay
, Qwindow
);
5583 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5586 /* If the text ``under'' the overlay is invisible, it has a zero
5587 dimension, and both before- and after-strings apply. */
5588 invisible
= Foverlay_get (overlay
, Qinvisible
);
5589 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5591 /* If overlay has a non-empty before-string, record it. */
5592 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5593 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5595 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5597 /* If overlay has a non-empty after-string, record it. */
5598 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5599 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5601 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5604 #undef RECORD_OVERLAY_STRING
5608 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
5610 /* Record number of overlay strings, and where we computed it. */
5611 it
->n_overlay_strings
= n
;
5612 it
->overlay_strings_charpos
= charpos
;
5614 /* IT->current.overlay_string_index is the number of overlay strings
5615 that have already been consumed by IT. Copy some of the
5616 remaining overlay strings to IT->overlay_strings. */
5618 j
= it
->current
.overlay_string_index
;
5619 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
5621 it
->overlay_strings
[i
] = entries
[j
].string
;
5622 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
5630 /* Get the first chunk of overlay strings at IT's current buffer
5631 position, or at CHARPOS if that is > 0. Value is non-zero if at
5632 least one overlay string was found. */
5635 get_overlay_strings_1 (struct it
*it
, ptrdiff_t charpos
, int compute_stop_p
)
5637 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5638 process. This fills IT->overlay_strings with strings, and sets
5639 IT->n_overlay_strings to the total number of strings to process.
5640 IT->pos.overlay_string_index has to be set temporarily to zero
5641 because load_overlay_strings needs this; it must be set to -1
5642 when no overlay strings are found because a zero value would
5643 indicate a position in the first overlay string. */
5644 it
->current
.overlay_string_index
= 0;
5645 load_overlay_strings (it
, charpos
);
5647 /* If we found overlay strings, set up IT to deliver display
5648 elements from the first one. Otherwise set up IT to deliver
5649 from current_buffer. */
5650 if (it
->n_overlay_strings
)
5652 /* Make sure we know settings in current_buffer, so that we can
5653 restore meaningful values when we're done with the overlay
5656 compute_stop_pos (it
);
5657 eassert (it
->face_id
>= 0);
5659 /* Save IT's settings. They are restored after all overlay
5660 strings have been processed. */
5661 eassert (!compute_stop_p
|| it
->sp
== 0);
5663 /* When called from handle_stop, there might be an empty display
5664 string loaded. In that case, don't bother saving it. But
5665 don't use this optimization with the bidi iterator, since we
5666 need the corresponding pop_it call to resync the bidi
5667 iterator's position with IT's position, after we are done
5668 with the overlay strings. (The corresponding call to pop_it
5669 in case of an empty display string is in
5670 next_overlay_string.) */
5672 && STRINGP (it
->string
) && !SCHARS (it
->string
)))
5675 /* Set up IT to deliver display elements from the first overlay
5677 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5678 it
->string
= it
->overlay_strings
[0];
5679 it
->from_overlay
= Qnil
;
5680 it
->stop_charpos
= 0;
5681 eassert (STRINGP (it
->string
));
5682 it
->end_charpos
= SCHARS (it
->string
);
5684 it
->base_level_stop
= 0;
5685 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5686 it
->method
= GET_FROM_STRING
;
5687 it
->from_disp_prop_p
= 0;
5689 /* Force paragraph direction to be that of the parent
5691 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5692 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5694 it
->paragraph_embedding
= L2R
;
5696 /* Set up the bidi iterator for this overlay string. */
5699 ptrdiff_t pos
= (charpos
> 0 ? charpos
: IT_CHARPOS (*it
));
5701 it
->bidi_it
.string
.lstring
= it
->string
;
5702 it
->bidi_it
.string
.s
= NULL
;
5703 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5704 it
->bidi_it
.string
.bufpos
= pos
;
5705 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5706 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5707 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5712 it
->current
.overlay_string_index
= -1;
5717 get_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5720 it
->method
= GET_FROM_BUFFER
;
5722 (void) get_overlay_strings_1 (it
, charpos
, 1);
5726 /* Value is non-zero if we found at least one overlay string. */
5727 return STRINGP (it
->string
);
5732 /***********************************************************************
5733 Saving and restoring state
5734 ***********************************************************************/
5736 /* Save current settings of IT on IT->stack. Called, for example,
5737 before setting up IT for an overlay string, to be able to restore
5738 IT's settings to what they were after the overlay string has been
5739 processed. If POSITION is non-NULL, it is the position to save on
5740 the stack instead of IT->position. */
5743 push_it (struct it
*it
, struct text_pos
*position
)
5745 struct iterator_stack_entry
*p
;
5747 eassert (it
->sp
< IT_STACK_SIZE
);
5748 p
= it
->stack
+ it
->sp
;
5750 p
->stop_charpos
= it
->stop_charpos
;
5751 p
->prev_stop
= it
->prev_stop
;
5752 p
->base_level_stop
= it
->base_level_stop
;
5753 p
->cmp_it
= it
->cmp_it
;
5754 eassert (it
->face_id
>= 0);
5755 p
->face_id
= it
->face_id
;
5756 p
->string
= it
->string
;
5757 p
->method
= it
->method
;
5758 p
->from_overlay
= it
->from_overlay
;
5761 case GET_FROM_IMAGE
:
5762 p
->u
.image
.object
= it
->object
;
5763 p
->u
.image
.image_id
= it
->image_id
;
5764 p
->u
.image
.slice
= it
->slice
;
5766 case GET_FROM_STRETCH
:
5767 p
->u
.stretch
.object
= it
->object
;
5770 p
->position
= position
? *position
: it
->position
;
5771 p
->current
= it
->current
;
5772 p
->end_charpos
= it
->end_charpos
;
5773 p
->string_nchars
= it
->string_nchars
;
5775 p
->multibyte_p
= it
->multibyte_p
;
5776 p
->avoid_cursor_p
= it
->avoid_cursor_p
;
5777 p
->space_width
= it
->space_width
;
5778 p
->font_height
= it
->font_height
;
5779 p
->voffset
= it
->voffset
;
5780 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5781 p
->string_from_prefix_prop_p
= it
->string_from_prefix_prop_p
;
5782 p
->display_ellipsis_p
= 0;
5783 p
->line_wrap
= it
->line_wrap
;
5784 p
->bidi_p
= it
->bidi_p
;
5785 p
->paragraph_embedding
= it
->paragraph_embedding
;
5786 p
->from_disp_prop_p
= it
->from_disp_prop_p
;
5789 /* Save the state of the bidi iterator as well. */
5791 bidi_push_it (&it
->bidi_it
);
5795 iterate_out_of_display_property (struct it
*it
)
5797 int buffer_p
= !STRINGP (it
->string
);
5798 ptrdiff_t eob
= (buffer_p
? ZV
: it
->end_charpos
);
5799 ptrdiff_t bob
= (buffer_p
? BEGV
: 0);
5801 eassert (eob
>= CHARPOS (it
->position
) && CHARPOS (it
->position
) >= bob
);
5803 /* Maybe initialize paragraph direction. If we are at the beginning
5804 of a new paragraph, next_element_from_buffer may not have a
5805 chance to do that. */
5806 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< eob
)
5807 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
5808 /* prev_stop can be zero, so check against BEGV as well. */
5809 while (it
->bidi_it
.charpos
>= bob
5810 && it
->prev_stop
<= it
->bidi_it
.charpos
5811 && it
->bidi_it
.charpos
< CHARPOS (it
->position
)
5812 && it
->bidi_it
.charpos
< eob
)
5813 bidi_move_to_visually_next (&it
->bidi_it
);
5814 /* Record the stop_pos we just crossed, for when we cross it
5816 if (it
->bidi_it
.charpos
> CHARPOS (it
->position
))
5817 it
->prev_stop
= CHARPOS (it
->position
);
5818 /* If we ended up not where pop_it put us, resync IT's
5819 positional members with the bidi iterator. */
5820 if (it
->bidi_it
.charpos
!= CHARPOS (it
->position
))
5821 SET_TEXT_POS (it
->position
, it
->bidi_it
.charpos
, it
->bidi_it
.bytepos
);
5823 it
->current
.pos
= it
->position
;
5825 it
->current
.string_pos
= it
->position
;
5828 /* Restore IT's settings from IT->stack. Called, for example, when no
5829 more overlay strings must be processed, and we return to delivering
5830 display elements from a buffer, or when the end of a string from a
5831 `display' property is reached and we return to delivering display
5832 elements from an overlay string, or from a buffer. */
5835 pop_it (struct it
*it
)
5837 struct iterator_stack_entry
*p
;
5838 int from_display_prop
= it
->from_disp_prop_p
;
5840 eassert (it
->sp
> 0);
5842 p
= it
->stack
+ it
->sp
;
5843 it
->stop_charpos
= p
->stop_charpos
;
5844 it
->prev_stop
= p
->prev_stop
;
5845 it
->base_level_stop
= p
->base_level_stop
;
5846 it
->cmp_it
= p
->cmp_it
;
5847 it
->face_id
= p
->face_id
;
5848 it
->current
= p
->current
;
5849 it
->position
= p
->position
;
5850 it
->string
= p
->string
;
5851 it
->from_overlay
= p
->from_overlay
;
5852 if (NILP (it
->string
))
5853 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
5854 it
->method
= p
->method
;
5857 case GET_FROM_IMAGE
:
5858 it
->image_id
= p
->u
.image
.image_id
;
5859 it
->object
= p
->u
.image
.object
;
5860 it
->slice
= p
->u
.image
.slice
;
5862 case GET_FROM_STRETCH
:
5863 it
->object
= p
->u
.stretch
.object
;
5865 case GET_FROM_BUFFER
:
5866 it
->object
= it
->w
->buffer
;
5868 case GET_FROM_STRING
:
5869 it
->object
= it
->string
;
5871 case GET_FROM_DISPLAY_VECTOR
:
5873 it
->method
= GET_FROM_C_STRING
;
5874 else if (STRINGP (it
->string
))
5875 it
->method
= GET_FROM_STRING
;
5878 it
->method
= GET_FROM_BUFFER
;
5879 it
->object
= it
->w
->buffer
;
5882 it
->end_charpos
= p
->end_charpos
;
5883 it
->string_nchars
= p
->string_nchars
;
5885 it
->multibyte_p
= p
->multibyte_p
;
5886 it
->avoid_cursor_p
= p
->avoid_cursor_p
;
5887 it
->space_width
= p
->space_width
;
5888 it
->font_height
= p
->font_height
;
5889 it
->voffset
= p
->voffset
;
5890 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
5891 it
->string_from_prefix_prop_p
= p
->string_from_prefix_prop_p
;
5892 it
->line_wrap
= p
->line_wrap
;
5893 it
->bidi_p
= p
->bidi_p
;
5894 it
->paragraph_embedding
= p
->paragraph_embedding
;
5895 it
->from_disp_prop_p
= p
->from_disp_prop_p
;
5898 bidi_pop_it (&it
->bidi_it
);
5899 /* Bidi-iterate until we get out of the portion of text, if any,
5900 covered by a `display' text property or by an overlay with
5901 `display' property. (We cannot just jump there, because the
5902 internal coherency of the bidi iterator state can not be
5903 preserved across such jumps.) We also must determine the
5904 paragraph base direction if the overlay we just processed is
5905 at the beginning of a new paragraph. */
5906 if (from_display_prop
5907 && (it
->method
== GET_FROM_BUFFER
|| it
->method
== GET_FROM_STRING
))
5908 iterate_out_of_display_property (it
);
5910 eassert ((BUFFERP (it
->object
)
5911 && IT_CHARPOS (*it
) == it
->bidi_it
.charpos
5912 && IT_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
5913 || (STRINGP (it
->object
)
5914 && IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
5915 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
5916 || (CONSP (it
->object
) && it
->method
== GET_FROM_STRETCH
));
5922 /***********************************************************************
5924 ***********************************************************************/
5926 /* Set IT's current position to the previous line start. */
5929 back_to_previous_line_start (struct it
*it
)
5931 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
5932 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
5936 /* Move IT to the next line start.
5938 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5939 we skipped over part of the text (as opposed to moving the iterator
5940 continuously over the text). Otherwise, don't change the value
5943 If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
5944 iterator on the newline, if it was found.
5946 Newlines may come from buffer text, overlay strings, or strings
5947 displayed via the `display' property. That's the reason we can't
5948 simply use find_next_newline_no_quit.
5950 Note that this function may not skip over invisible text that is so
5951 because of text properties and immediately follows a newline. If
5952 it would, function reseat_at_next_visible_line_start, when called
5953 from set_iterator_to_next, would effectively make invisible
5954 characters following a newline part of the wrong glyph row, which
5955 leads to wrong cursor motion. */
5958 forward_to_next_line_start (struct it
*it
, int *skipped_p
,
5959 struct bidi_it
*bidi_it_prev
)
5961 ptrdiff_t old_selective
;
5962 int newline_found_p
, n
;
5963 const int MAX_NEWLINE_DISTANCE
= 500;
5965 /* If already on a newline, just consume it to avoid unintended
5966 skipping over invisible text below. */
5967 if (it
->what
== IT_CHARACTER
5969 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
5971 if (it
->bidi_p
&& bidi_it_prev
)
5972 *bidi_it_prev
= it
->bidi_it
;
5973 set_iterator_to_next (it
, 0);
5978 /* Don't handle selective display in the following. It's (a)
5979 unnecessary because it's done by the caller, and (b) leads to an
5980 infinite recursion because next_element_from_ellipsis indirectly
5981 calls this function. */
5982 old_selective
= it
->selective
;
5985 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5986 from buffer text. */
5987 for (n
= newline_found_p
= 0;
5988 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
5989 n
+= STRINGP (it
->string
) ? 0 : 1)
5991 if (!get_next_display_element (it
))
5993 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
5994 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
5995 *bidi_it_prev
= it
->bidi_it
;
5996 set_iterator_to_next (it
, 0);
5999 /* If we didn't find a newline near enough, see if we can use a
6001 if (!newline_found_p
)
6003 ptrdiff_t start
= IT_CHARPOS (*it
);
6004 ptrdiff_t limit
= find_next_newline_no_quit (start
, 1);
6007 eassert (!STRINGP (it
->string
));
6009 /* If there isn't any `display' property in sight, and no
6010 overlays, we can just use the position of the newline in
6012 if (it
->stop_charpos
>= limit
6013 || ((pos
= Fnext_single_property_change (make_number (start
),
6015 make_number (limit
)),
6017 && next_overlay_change (start
) == ZV
))
6021 IT_CHARPOS (*it
) = limit
;
6022 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
6026 struct bidi_it bprev
;
6028 /* Help bidi.c avoid expensive searches for display
6029 properties and overlays, by telling it that there are
6030 none up to `limit'. */
6031 if (it
->bidi_it
.disp_pos
< limit
)
6033 it
->bidi_it
.disp_pos
= limit
;
6034 it
->bidi_it
.disp_prop
= 0;
6037 bprev
= it
->bidi_it
;
6038 bidi_move_to_visually_next (&it
->bidi_it
);
6039 } while (it
->bidi_it
.charpos
!= limit
);
6040 IT_CHARPOS (*it
) = limit
;
6041 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6043 *bidi_it_prev
= bprev
;
6045 *skipped_p
= newline_found_p
= 1;
6049 while (get_next_display_element (it
)
6050 && !newline_found_p
)
6052 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
6053 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
6054 *bidi_it_prev
= it
->bidi_it
;
6055 set_iterator_to_next (it
, 0);
6060 it
->selective
= old_selective
;
6061 return newline_found_p
;
6065 /* Set IT's current position to the previous visible line start. Skip
6066 invisible text that is so either due to text properties or due to
6067 selective display. Caution: this does not change IT->current_x and
6071 back_to_previous_visible_line_start (struct it
*it
)
6073 while (IT_CHARPOS (*it
) > BEGV
)
6075 back_to_previous_line_start (it
);
6077 if (IT_CHARPOS (*it
) <= BEGV
)
6080 /* If selective > 0, then lines indented more than its value are
6082 if (it
->selective
> 0
6083 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6087 /* Check the newline before point for invisibility. */
6090 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
6091 Qinvisible
, it
->window
);
6092 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
6096 if (IT_CHARPOS (*it
) <= BEGV
)
6101 void *it2data
= NULL
;
6104 Lisp_Object val
, overlay
;
6106 SAVE_IT (it2
, *it
, it2data
);
6108 /* If newline is part of a composition, continue from start of composition */
6109 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
6110 && beg
< IT_CHARPOS (*it
))
6113 /* If newline is replaced by a display property, find start of overlay
6114 or interval and continue search from that point. */
6115 pos
= --IT_CHARPOS (it2
);
6118 bidi_unshelve_cache (NULL
, 0);
6119 it2
.string_from_display_prop_p
= 0;
6120 it2
.from_disp_prop_p
= 0;
6121 if (handle_display_prop (&it2
) == HANDLED_RETURN
6122 && !NILP (val
= get_char_property_and_overlay
6123 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
6124 && (OVERLAYP (overlay
)
6125 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
6126 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
6128 RESTORE_IT (it
, it
, it2data
);
6132 /* Newline is not replaced by anything -- so we are done. */
6133 RESTORE_IT (it
, it
, it2data
);
6139 IT_CHARPOS (*it
) = beg
;
6140 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
6144 it
->continuation_lines_width
= 0;
6146 eassert (IT_CHARPOS (*it
) >= BEGV
);
6147 eassert (IT_CHARPOS (*it
) == BEGV
6148 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6153 /* Reseat iterator IT at the previous visible line start. Skip
6154 invisible text that is so either due to text properties or due to
6155 selective display. At the end, update IT's overlay information,
6156 face information etc. */
6159 reseat_at_previous_visible_line_start (struct it
*it
)
6161 back_to_previous_visible_line_start (it
);
6162 reseat (it
, it
->current
.pos
, 1);
6167 /* Reseat iterator IT on the next visible line start in the current
6168 buffer. ON_NEWLINE_P non-zero means position IT on the newline
6169 preceding the line start. Skip over invisible text that is so
6170 because of selective display. Compute faces, overlays etc at the
6171 new position. Note that this function does not skip over text that
6172 is invisible because of text properties. */
6175 reseat_at_next_visible_line_start (struct it
*it
, int on_newline_p
)
6177 int newline_found_p
, skipped_p
= 0;
6178 struct bidi_it bidi_it_prev
;
6180 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6182 /* Skip over lines that are invisible because they are indented
6183 more than the value of IT->selective. */
6184 if (it
->selective
> 0)
6185 while (IT_CHARPOS (*it
) < ZV
6186 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6189 eassert (IT_BYTEPOS (*it
) == BEGV
6190 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6192 forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6195 /* Position on the newline if that's what's requested. */
6196 if (on_newline_p
&& newline_found_p
)
6198 if (STRINGP (it
->string
))
6200 if (IT_STRING_CHARPOS (*it
) > 0)
6204 --IT_STRING_CHARPOS (*it
);
6205 --IT_STRING_BYTEPOS (*it
);
6209 /* We need to restore the bidi iterator to the state
6210 it had on the newline, and resync the IT's
6211 position with that. */
6212 it
->bidi_it
= bidi_it_prev
;
6213 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6214 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6218 else if (IT_CHARPOS (*it
) > BEGV
)
6227 /* We need to restore the bidi iterator to the state it
6228 had on the newline and resync IT with that. */
6229 it
->bidi_it
= bidi_it_prev
;
6230 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6231 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6233 reseat (it
, it
->current
.pos
, 0);
6237 reseat (it
, it
->current
.pos
, 0);
6244 /***********************************************************************
6245 Changing an iterator's position
6246 ***********************************************************************/
6248 /* Change IT's current position to POS in current_buffer. If FORCE_P
6249 is non-zero, always check for text properties at the new position.
6250 Otherwise, text properties are only looked up if POS >=
6251 IT->check_charpos of a property. */
6254 reseat (struct it
*it
, struct text_pos pos
, int force_p
)
6256 ptrdiff_t original_pos
= IT_CHARPOS (*it
);
6258 reseat_1 (it
, pos
, 0);
6260 /* Determine where to check text properties. Avoid doing it
6261 where possible because text property lookup is very expensive. */
6263 || CHARPOS (pos
) > it
->stop_charpos
6264 || CHARPOS (pos
) < original_pos
)
6268 /* For bidi iteration, we need to prime prev_stop and
6269 base_level_stop with our best estimations. */
6270 /* Implementation note: Of course, POS is not necessarily a
6271 stop position, so assigning prev_pos to it is a lie; we
6272 should have called compute_stop_backwards. However, if
6273 the current buffer does not include any R2L characters,
6274 that call would be a waste of cycles, because the
6275 iterator will never move back, and thus never cross this
6276 "fake" stop position. So we delay that backward search
6277 until the time we really need it, in next_element_from_buffer. */
6278 if (CHARPOS (pos
) != it
->prev_stop
)
6279 it
->prev_stop
= CHARPOS (pos
);
6280 if (CHARPOS (pos
) < it
->base_level_stop
)
6281 it
->base_level_stop
= 0; /* meaning it's unknown */
6287 it
->prev_stop
= it
->base_level_stop
= 0;
6296 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
6297 IT->stop_pos to POS, also. */
6300 reseat_1 (struct it
*it
, struct text_pos pos
, int set_stop_p
)
6302 /* Don't call this function when scanning a C string. */
6303 eassert (it
->s
== NULL
);
6305 /* POS must be a reasonable value. */
6306 eassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
6308 it
->current
.pos
= it
->position
= pos
;
6309 it
->end_charpos
= ZV
;
6311 it
->current
.dpvec_index
= -1;
6312 it
->current
.overlay_string_index
= -1;
6313 IT_STRING_CHARPOS (*it
) = -1;
6314 IT_STRING_BYTEPOS (*it
) = -1;
6316 it
->method
= GET_FROM_BUFFER
;
6317 it
->object
= it
->w
->buffer
;
6318 it
->area
= TEXT_AREA
;
6319 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
6321 it
->string_from_display_prop_p
= 0;
6322 it
->string_from_prefix_prop_p
= 0;
6324 it
->from_disp_prop_p
= 0;
6325 it
->face_before_selective_p
= 0;
6328 bidi_init_it (IT_CHARPOS (*it
), IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6330 bidi_unshelve_cache (NULL
, 0);
6331 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6332 it
->bidi_it
.string
.s
= NULL
;
6333 it
->bidi_it
.string
.lstring
= Qnil
;
6334 it
->bidi_it
.string
.bufpos
= 0;
6335 it
->bidi_it
.string
.unibyte
= 0;
6340 it
->stop_charpos
= CHARPOS (pos
);
6341 it
->base_level_stop
= CHARPOS (pos
);
6343 /* This make the information stored in it->cmp_it invalidate. */
6348 /* Set up IT for displaying a string, starting at CHARPOS in window W.
6349 If S is non-null, it is a C string to iterate over. Otherwise,
6350 STRING gives a Lisp string to iterate over.
6352 If PRECISION > 0, don't return more then PRECISION number of
6353 characters from the string.
6355 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
6356 characters have been returned. FIELD_WIDTH < 0 means an infinite
6359 MULTIBYTE = 0 means disable processing of multibyte characters,
6360 MULTIBYTE > 0 means enable it,
6361 MULTIBYTE < 0 means use IT->multibyte_p.
6363 IT must be initialized via a prior call to init_iterator before
6364 calling this function. */
6367 reseat_to_string (struct it
*it
, const char *s
, Lisp_Object string
,
6368 ptrdiff_t charpos
, ptrdiff_t precision
, int field_width
,
6371 /* No region in strings. */
6372 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
6374 /* No text property checks performed by default, but see below. */
6375 it
->stop_charpos
= -1;
6377 /* Set iterator position and end position. */
6378 memset (&it
->current
, 0, sizeof it
->current
);
6379 it
->current
.overlay_string_index
= -1;
6380 it
->current
.dpvec_index
= -1;
6381 eassert (charpos
>= 0);
6383 /* If STRING is specified, use its multibyteness, otherwise use the
6384 setting of MULTIBYTE, if specified. */
6386 it
->multibyte_p
= multibyte
> 0;
6388 /* Bidirectional reordering of strings is controlled by the default
6389 value of bidi-display-reordering. Don't try to reorder while
6390 loading loadup.el, as the necessary character property tables are
6391 not yet available. */
6394 && !NILP (BVAR (&buffer_defaults
, bidi_display_reordering
));
6398 eassert (STRINGP (string
));
6399 it
->string
= string
;
6401 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
6402 it
->method
= GET_FROM_STRING
;
6403 it
->current
.string_pos
= string_pos (charpos
, string
);
6407 it
->bidi_it
.string
.lstring
= string
;
6408 it
->bidi_it
.string
.s
= NULL
;
6409 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6410 it
->bidi_it
.string
.bufpos
= 0;
6411 it
->bidi_it
.string
.from_disp_str
= 0;
6412 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6413 bidi_init_it (charpos
, IT_STRING_BYTEPOS (*it
),
6414 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
6419 it
->s
= (const unsigned char *) s
;
6422 /* Note that we use IT->current.pos, not it->current.string_pos,
6423 for displaying C strings. */
6424 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
6425 if (it
->multibyte_p
)
6427 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
6428 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
6432 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
6433 it
->end_charpos
= it
->string_nchars
= strlen (s
);
6438 it
->bidi_it
.string
.lstring
= Qnil
;
6439 it
->bidi_it
.string
.s
= (const unsigned char *) s
;
6440 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6441 it
->bidi_it
.string
.bufpos
= 0;
6442 it
->bidi_it
.string
.from_disp_str
= 0;
6443 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6444 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6447 it
->method
= GET_FROM_C_STRING
;
6450 /* PRECISION > 0 means don't return more than PRECISION characters
6452 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
6454 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
6456 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6459 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
6460 characters have been returned. FIELD_WIDTH == 0 means don't pad,
6461 FIELD_WIDTH < 0 means infinite field width. This is useful for
6462 padding with `-' at the end of a mode line. */
6463 if (field_width
< 0)
6464 field_width
= INFINITY
;
6465 /* Implementation note: We deliberately don't enlarge
6466 it->bidi_it.string.schars here to fit it->end_charpos, because
6467 the bidi iterator cannot produce characters out of thin air. */
6468 if (field_width
> it
->end_charpos
- charpos
)
6469 it
->end_charpos
= charpos
+ field_width
;
6471 /* Use the standard display table for displaying strings. */
6472 if (DISP_TABLE_P (Vstandard_display_table
))
6473 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
6475 it
->stop_charpos
= charpos
;
6476 it
->prev_stop
= charpos
;
6477 it
->base_level_stop
= 0;
6480 it
->bidi_it
.first_elt
= 1;
6481 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6482 it
->bidi_it
.disp_pos
= -1;
6484 if (s
== NULL
&& it
->multibyte_p
)
6486 ptrdiff_t endpos
= SCHARS (it
->string
);
6487 if (endpos
> it
->end_charpos
)
6488 endpos
= it
->end_charpos
;
6489 composition_compute_stop_pos (&it
->cmp_it
, charpos
, -1, endpos
,
6497 /***********************************************************************
6499 ***********************************************************************/
6501 /* Map enum it_method value to corresponding next_element_from_* function. */
6503 static int (* get_next_element
[NUM_IT_METHODS
]) (struct it
*it
) =
6505 next_element_from_buffer
,
6506 next_element_from_display_vector
,
6507 next_element_from_string
,
6508 next_element_from_c_string
,
6509 next_element_from_image
,
6510 next_element_from_stretch
6513 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
6516 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
6517 (possibly with the following characters). */
6519 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
6520 ((IT)->cmp_it.id >= 0 \
6521 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
6522 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
6523 END_CHARPOS, (IT)->w, \
6524 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
6528 /* Lookup the char-table Vglyphless_char_display for character C (-1
6529 if we want information for no-font case), and return the display
6530 method symbol. By side-effect, update it->what and
6531 it->glyphless_method. This function is called from
6532 get_next_display_element for each character element, and from
6533 x_produce_glyphs when no suitable font was found. */
6536 lookup_glyphless_char_display (int c
, struct it
*it
)
6538 Lisp_Object glyphless_method
= Qnil
;
6540 if (CHAR_TABLE_P (Vglyphless_char_display
)
6541 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
)) >= 1)
6545 glyphless_method
= CHAR_TABLE_REF (Vglyphless_char_display
, c
);
6546 if (CONSP (glyphless_method
))
6547 glyphless_method
= FRAME_WINDOW_P (it
->f
)
6548 ? XCAR (glyphless_method
)
6549 : XCDR (glyphless_method
);
6552 glyphless_method
= XCHAR_TABLE (Vglyphless_char_display
)->extras
[0];
6556 if (NILP (glyphless_method
))
6559 /* The default is to display the character by a proper font. */
6561 /* The default for the no-font case is to display an empty box. */
6562 glyphless_method
= Qempty_box
;
6564 if (EQ (glyphless_method
, Qzero_width
))
6567 return glyphless_method
;
6568 /* This method can't be used for the no-font case. */
6569 glyphless_method
= Qempty_box
;
6571 if (EQ (glyphless_method
, Qthin_space
))
6572 it
->glyphless_method
= GLYPHLESS_DISPLAY_THIN_SPACE
;
6573 else if (EQ (glyphless_method
, Qempty_box
))
6574 it
->glyphless_method
= GLYPHLESS_DISPLAY_EMPTY_BOX
;
6575 else if (EQ (glyphless_method
, Qhex_code
))
6576 it
->glyphless_method
= GLYPHLESS_DISPLAY_HEX_CODE
;
6577 else if (STRINGP (glyphless_method
))
6578 it
->glyphless_method
= GLYPHLESS_DISPLAY_ACRONYM
;
6581 /* Invalid value. We use the default method. */
6582 glyphless_method
= Qnil
;
6585 it
->what
= IT_GLYPHLESS
;
6586 return glyphless_method
;
6589 /* Load IT's display element fields with information about the next
6590 display element from the current position of IT. Value is zero if
6591 end of buffer (or C string) is reached. */
6593 static struct frame
*last_escape_glyph_frame
= NULL
;
6594 static int last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
6595 static int last_escape_glyph_merged_face_id
= 0;
6597 struct frame
*last_glyphless_glyph_frame
= NULL
;
6598 int last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
6599 int last_glyphless_glyph_merged_face_id
= 0;
6602 get_next_display_element (struct it
*it
)
6604 /* Non-zero means that we found a display element. Zero means that
6605 we hit the end of what we iterate over. Performance note: the
6606 function pointer `method' used here turns out to be faster than
6607 using a sequence of if-statements. */
6611 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
6613 if (it
->what
== IT_CHARACTER
)
6615 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
6616 and only if (a) the resolved directionality of that character
6618 /* FIXME: Do we need an exception for characters from display
6620 if (it
->bidi_p
&& it
->bidi_it
.type
== STRONG_R
)
6621 it
->c
= bidi_mirror_char (it
->c
);
6622 /* Map via display table or translate control characters.
6623 IT->c, IT->len etc. have been set to the next character by
6624 the function call above. If we have a display table, and it
6625 contains an entry for IT->c, translate it. Don't do this if
6626 IT->c itself comes from a display table, otherwise we could
6627 end up in an infinite recursion. (An alternative could be to
6628 count the recursion depth of this function and signal an
6629 error when a certain maximum depth is reached.) Is it worth
6631 if (success_p
&& it
->dpvec
== NULL
)
6634 struct charset
*unibyte
= CHARSET_FROM_ID (charset_unibyte
);
6635 int nonascii_space_p
= 0;
6636 int nonascii_hyphen_p
= 0;
6637 int c
= it
->c
; /* This is the character to display. */
6639 if (! it
->multibyte_p
&& ! ASCII_CHAR_P (c
))
6641 eassert (SINGLE_BYTE_CHAR_P (c
));
6642 if (unibyte_display_via_language_environment
)
6644 c
= DECODE_CHAR (unibyte
, c
);
6646 c
= BYTE8_TO_CHAR (it
->c
);
6649 c
= BYTE8_TO_CHAR (it
->c
);
6653 && (dv
= DISP_CHAR_VECTOR (it
->dp
, c
),
6656 struct Lisp_Vector
*v
= XVECTOR (dv
);
6658 /* Return the first character from the display table
6659 entry, if not empty. If empty, don't display the
6660 current character. */
6663 it
->dpvec_char_len
= it
->len
;
6664 it
->dpvec
= v
->contents
;
6665 it
->dpend
= v
->contents
+ v
->header
.size
;
6666 it
->current
.dpvec_index
= 0;
6667 it
->dpvec_face_id
= -1;
6668 it
->saved_face_id
= it
->face_id
;
6669 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6674 set_iterator_to_next (it
, 0);
6679 if (! NILP (lookup_glyphless_char_display (c
, it
)))
6681 if (it
->what
== IT_GLYPHLESS
)
6683 /* Don't display this character. */
6684 set_iterator_to_next (it
, 0);
6688 /* If `nobreak-char-display' is non-nil, we display
6689 non-ASCII spaces and hyphens specially. */
6690 if (! ASCII_CHAR_P (c
) && ! NILP (Vnobreak_char_display
))
6693 nonascii_space_p
= 1;
6694 else if (c
== 0xAD || c
== 0x2010 || c
== 0x2011)
6695 nonascii_hyphen_p
= 1;
6698 /* Translate control characters into `\003' or `^C' form.
6699 Control characters coming from a display table entry are
6700 currently not translated because we use IT->dpvec to hold
6701 the translation. This could easily be changed but I
6702 don't believe that it is worth doing.
6704 The characters handled by `nobreak-char-display' must be
6707 Non-printable characters and raw-byte characters are also
6708 translated to octal form. */
6709 if (((c
< ' ' || c
== 127) /* ASCII control chars */
6710 ? (it
->area
!= TEXT_AREA
6711 /* In mode line, treat \n, \t like other crl chars. */
6714 && (it
->glyph_row
->mode_line_p
|| it
->avoid_cursor_p
))
6715 || (c
!= '\n' && c
!= '\t'))
6717 || nonascii_hyphen_p
6719 || ! CHAR_PRINTABLE_P (c
))))
6721 /* C is a control character, non-ASCII space/hyphen,
6722 raw-byte, or a non-printable character which must be
6723 displayed either as '\003' or as `^C' where the '\\'
6724 and '^' can be defined in the display table. Fill
6725 IT->ctl_chars with glyphs for what we have to
6726 display. Then, set IT->dpvec to these glyphs. */
6733 /* Handle control characters with ^. */
6735 if (ASCII_CHAR_P (c
) && it
->ctl_arrow_p
)
6739 g
= '^'; /* default glyph for Control */
6740 /* Set IT->ctl_chars[0] to the glyph for `^'. */
6742 && (gc
= DISP_CTRL_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
6744 g
= GLYPH_CODE_CHAR (gc
);
6745 lface_id
= GLYPH_CODE_FACE (gc
);
6749 face_id
= merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
);
6751 else if (it
->f
== last_escape_glyph_frame
6752 && it
->face_id
== last_escape_glyph_face_id
)
6754 face_id
= last_escape_glyph_merged_face_id
;
6758 /* Merge the escape-glyph face into the current face. */
6759 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6761 last_escape_glyph_frame
= it
->f
;
6762 last_escape_glyph_face_id
= it
->face_id
;
6763 last_escape_glyph_merged_face_id
= face_id
;
6766 XSETINT (it
->ctl_chars
[0], g
);
6767 XSETINT (it
->ctl_chars
[1], c
^ 0100);
6769 goto display_control
;
6772 /* Handle non-ascii space in the mode where it only gets
6775 if (nonascii_space_p
&& EQ (Vnobreak_char_display
, Qt
))
6777 /* Merge `nobreak-space' into the current face. */
6778 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
6780 XSETINT (it
->ctl_chars
[0], ' ');
6782 goto display_control
;
6785 /* Handle sequences that start with the "escape glyph". */
6787 /* the default escape glyph is \. */
6788 escape_glyph
= '\\';
6791 && (gc
= DISP_ESCAPE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
6793 escape_glyph
= GLYPH_CODE_CHAR (gc
);
6794 lface_id
= GLYPH_CODE_FACE (gc
);
6798 /* The display table specified a face.
6799 Merge it into face_id and also into escape_glyph. */
6800 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6803 else if (it
->f
== last_escape_glyph_frame
6804 && it
->face_id
== last_escape_glyph_face_id
)
6806 face_id
= last_escape_glyph_merged_face_id
;
6810 /* Merge the escape-glyph face into the current face. */
6811 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6813 last_escape_glyph_frame
= it
->f
;
6814 last_escape_glyph_face_id
= it
->face_id
;
6815 last_escape_glyph_merged_face_id
= face_id
;
6818 /* Draw non-ASCII hyphen with just highlighting: */
6820 if (nonascii_hyphen_p
&& EQ (Vnobreak_char_display
, Qt
))
6822 XSETINT (it
->ctl_chars
[0], '-');
6824 goto display_control
;
6827 /* Draw non-ASCII space/hyphen with escape glyph: */
6829 if (nonascii_space_p
|| nonascii_hyphen_p
)
6831 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6832 XSETINT (it
->ctl_chars
[1], nonascii_space_p
? ' ' : '-');
6834 goto display_control
;
6841 if (CHAR_BYTE8_P (c
))
6842 /* Display \200 instead of \17777600. */
6843 c
= CHAR_TO_BYTE8 (c
);
6844 len
= sprintf (str
, "%03o", c
);
6846 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6847 for (i
= 0; i
< len
; i
++)
6848 XSETINT (it
->ctl_chars
[i
+ 1], str
[i
]);
6853 /* Set up IT->dpvec and return first character from it. */
6854 it
->dpvec_char_len
= it
->len
;
6855 it
->dpvec
= it
->ctl_chars
;
6856 it
->dpend
= it
->dpvec
+ ctl_len
;
6857 it
->current
.dpvec_index
= 0;
6858 it
->dpvec_face_id
= face_id
;
6859 it
->saved_face_id
= it
->face_id
;
6860 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6864 it
->char_to_display
= c
;
6868 it
->char_to_display
= it
->c
;
6872 /* Adjust face id for a multibyte character. There are no multibyte
6873 character in unibyte text. */
6874 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
6877 && FRAME_WINDOW_P (it
->f
))
6879 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
6881 if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
>= 0)
6883 /* Automatic composition with glyph-string. */
6884 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
6886 it
->face_id
= face_for_font (it
->f
, LGSTRING_FONT (gstring
), face
);
6890 ptrdiff_t pos
= (it
->s
? -1
6891 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
6892 : IT_CHARPOS (*it
));
6895 if (it
->what
== IT_CHARACTER
)
6896 c
= it
->char_to_display
;
6899 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
6903 for (i
= 0; i
< cmp
->glyph_len
; i
++)
6904 /* TAB in a composition means display glyphs with
6905 padding space on the left or right. */
6906 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
6909 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, pos
, it
->string
);
6914 /* Is this character the last one of a run of characters with
6915 box? If yes, set IT->end_of_box_run_p to 1. */
6919 if (it
->method
== GET_FROM_STRING
&& it
->sp
)
6921 int face_id
= underlying_face_id (it
);
6922 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
6926 if (face
->box
== FACE_NO_BOX
)
6928 /* If the box comes from face properties in a
6929 display string, check faces in that string. */
6930 int string_face_id
= face_after_it_pos (it
);
6931 it
->end_of_box_run_p
6932 = (FACE_FROM_ID (it
->f
, string_face_id
)->box
6935 /* Otherwise, the box comes from the underlying face.
6936 If this is the last string character displayed, check
6937 the next buffer location. */
6938 else if ((IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
) - 1)
6939 && (it
->current
.overlay_string_index
6940 == it
->n_overlay_strings
- 1))
6944 struct text_pos pos
= it
->current
.pos
;
6945 INC_TEXT_POS (pos
, it
->multibyte_p
);
6947 next_face_id
= face_at_buffer_position
6948 (it
->w
, CHARPOS (pos
), it
->region_beg_charpos
,
6949 it
->region_end_charpos
, &ignore
,
6950 (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
), 0,
6952 it
->end_of_box_run_p
6953 = (FACE_FROM_ID (it
->f
, next_face_id
)->box
6960 int face_id
= face_after_it_pos (it
);
6961 it
->end_of_box_run_p
6962 = (face_id
!= it
->face_id
6963 && FACE_FROM_ID (it
->f
, face_id
)->box
== FACE_NO_BOX
);
6966 /* If we reached the end of the object we've been iterating (e.g., a
6967 display string or an overlay string), and there's something on
6968 IT->stack, proceed with what's on the stack. It doesn't make
6969 sense to return zero if there's unprocessed stuff on the stack,
6970 because otherwise that stuff will never be displayed. */
6971 if (!success_p
&& it
->sp
> 0)
6973 set_iterator_to_next (it
, 0);
6974 success_p
= get_next_display_element (it
);
6977 /* Value is 0 if end of buffer or string reached. */
6982 /* Move IT to the next display element.
6984 RESEAT_P non-zero means if called on a newline in buffer text,
6985 skip to the next visible line start.
6987 Functions get_next_display_element and set_iterator_to_next are
6988 separate because I find this arrangement easier to handle than a
6989 get_next_display_element function that also increments IT's
6990 position. The way it is we can first look at an iterator's current
6991 display element, decide whether it fits on a line, and if it does,
6992 increment the iterator position. The other way around we probably
6993 would either need a flag indicating whether the iterator has to be
6994 incremented the next time, or we would have to implement a
6995 decrement position function which would not be easy to write. */
6998 set_iterator_to_next (struct it
*it
, int reseat_p
)
7000 /* Reset flags indicating start and end of a sequence of characters
7001 with box. Reset them at the start of this function because
7002 moving the iterator to a new position might set them. */
7003 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
7007 case GET_FROM_BUFFER
:
7008 /* The current display element of IT is a character from
7009 current_buffer. Advance in the buffer, and maybe skip over
7010 invisible lines that are so because of selective display. */
7011 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
7012 reseat_at_next_visible_line_start (it
, 0);
7013 else if (it
->cmp_it
.id
>= 0)
7015 /* We are currently getting glyphs from a composition. */
7020 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7021 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7022 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7024 it
->cmp_it
.from
= it
->cmp_it
.to
;
7029 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7031 it
->end_charpos
, Qnil
);
7034 else if (! it
->cmp_it
.reversed_p
)
7036 /* Composition created while scanning forward. */
7037 /* Update IT's char/byte positions to point to the first
7038 character of the next grapheme cluster, or to the
7039 character visually after the current composition. */
7040 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7041 bidi_move_to_visually_next (&it
->bidi_it
);
7042 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7043 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7045 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7047 /* Proceed to the next grapheme cluster. */
7048 it
->cmp_it
.from
= it
->cmp_it
.to
;
7052 /* No more grapheme clusters in this composition.
7053 Find the next stop position. */
7054 ptrdiff_t stop
= it
->end_charpos
;
7055 if (it
->bidi_it
.scan_dir
< 0)
7056 /* Now we are scanning backward and don't know
7059 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7060 IT_BYTEPOS (*it
), stop
, Qnil
);
7065 /* Composition created while scanning backward. */
7066 /* Update IT's char/byte positions to point to the last
7067 character of the previous grapheme cluster, or the
7068 character visually after the current composition. */
7069 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7070 bidi_move_to_visually_next (&it
->bidi_it
);
7071 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7072 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7073 if (it
->cmp_it
.from
> 0)
7075 /* Proceed to the previous grapheme cluster. */
7076 it
->cmp_it
.to
= it
->cmp_it
.from
;
7080 /* No more grapheme clusters in this composition.
7081 Find the next stop position. */
7082 ptrdiff_t stop
= it
->end_charpos
;
7083 if (it
->bidi_it
.scan_dir
< 0)
7084 /* Now we are scanning backward and don't know
7087 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7088 IT_BYTEPOS (*it
), stop
, Qnil
);
7094 eassert (it
->len
!= 0);
7098 IT_BYTEPOS (*it
) += it
->len
;
7099 IT_CHARPOS (*it
) += 1;
7103 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7104 /* If this is a new paragraph, determine its base
7105 direction (a.k.a. its base embedding level). */
7106 if (it
->bidi_it
.new_paragraph
)
7107 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
7108 bidi_move_to_visually_next (&it
->bidi_it
);
7109 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7110 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7111 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7113 /* As the scan direction was changed, we must
7114 re-compute the stop position for composition. */
7115 ptrdiff_t stop
= it
->end_charpos
;
7116 if (it
->bidi_it
.scan_dir
< 0)
7118 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7119 IT_BYTEPOS (*it
), stop
, Qnil
);
7122 eassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
7126 case GET_FROM_C_STRING
:
7127 /* Current display element of IT is from a C string. */
7129 /* If the string position is beyond string's end, it means
7130 next_element_from_c_string is padding the string with
7131 blanks, in which case we bypass the bidi iterator,
7132 because it cannot deal with such virtual characters. */
7133 || IT_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7135 IT_BYTEPOS (*it
) += it
->len
;
7136 IT_CHARPOS (*it
) += 1;
7140 bidi_move_to_visually_next (&it
->bidi_it
);
7141 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7142 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7146 case GET_FROM_DISPLAY_VECTOR
:
7147 /* Current display element of IT is from a display table entry.
7148 Advance in the display table definition. Reset it to null if
7149 end reached, and continue with characters from buffers/
7151 ++it
->current
.dpvec_index
;
7153 /* Restore face of the iterator to what they were before the
7154 display vector entry (these entries may contain faces). */
7155 it
->face_id
= it
->saved_face_id
;
7157 if (it
->dpvec
+ it
->current
.dpvec_index
>= it
->dpend
)
7159 int recheck_faces
= it
->ellipsis_p
;
7162 it
->method
= GET_FROM_C_STRING
;
7163 else if (STRINGP (it
->string
))
7164 it
->method
= GET_FROM_STRING
;
7167 it
->method
= GET_FROM_BUFFER
;
7168 it
->object
= it
->w
->buffer
;
7172 it
->current
.dpvec_index
= -1;
7174 /* Skip over characters which were displayed via IT->dpvec. */
7175 if (it
->dpvec_char_len
< 0)
7176 reseat_at_next_visible_line_start (it
, 1);
7177 else if (it
->dpvec_char_len
> 0)
7179 if (it
->method
== GET_FROM_STRING
7180 && it
->n_overlay_strings
> 0)
7181 it
->ignore_overlay_strings_at_pos_p
= 1;
7182 it
->len
= it
->dpvec_char_len
;
7183 set_iterator_to_next (it
, reseat_p
);
7186 /* Maybe recheck faces after display vector */
7188 it
->stop_charpos
= IT_CHARPOS (*it
);
7192 case GET_FROM_STRING
:
7193 /* Current display element is a character from a Lisp string. */
7194 eassert (it
->s
== NULL
&& STRINGP (it
->string
));
7195 /* Don't advance past string end. These conditions are true
7196 when set_iterator_to_next is called at the end of
7197 get_next_display_element, in which case the Lisp string is
7198 already exhausted, and all we want is pop the iterator
7200 if (it
->current
.overlay_string_index
>= 0)
7202 /* This is an overlay string, so there's no padding with
7203 spaces, and the number of characters in the string is
7204 where the string ends. */
7205 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7206 goto consider_string_end
;
7210 /* Not an overlay string. There could be padding, so test
7211 against it->end_charpos . */
7212 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7213 goto consider_string_end
;
7215 if (it
->cmp_it
.id
>= 0)
7221 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7222 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7223 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7224 it
->cmp_it
.from
= it
->cmp_it
.to
;
7228 composition_compute_stop_pos (&it
->cmp_it
,
7229 IT_STRING_CHARPOS (*it
),
7230 IT_STRING_BYTEPOS (*it
),
7231 it
->end_charpos
, it
->string
);
7234 else if (! it
->cmp_it
.reversed_p
)
7236 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7237 bidi_move_to_visually_next (&it
->bidi_it
);
7238 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7239 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7241 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7242 it
->cmp_it
.from
= it
->cmp_it
.to
;
7245 ptrdiff_t stop
= it
->end_charpos
;
7246 if (it
->bidi_it
.scan_dir
< 0)
7248 composition_compute_stop_pos (&it
->cmp_it
,
7249 IT_STRING_CHARPOS (*it
),
7250 IT_STRING_BYTEPOS (*it
), stop
,
7256 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7257 bidi_move_to_visually_next (&it
->bidi_it
);
7258 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7259 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7260 if (it
->cmp_it
.from
> 0)
7261 it
->cmp_it
.to
= it
->cmp_it
.from
;
7264 ptrdiff_t stop
= it
->end_charpos
;
7265 if (it
->bidi_it
.scan_dir
< 0)
7267 composition_compute_stop_pos (&it
->cmp_it
,
7268 IT_STRING_CHARPOS (*it
),
7269 IT_STRING_BYTEPOS (*it
), stop
,
7277 /* If the string position is beyond string's end, it
7278 means next_element_from_string is padding the string
7279 with blanks, in which case we bypass the bidi
7280 iterator, because it cannot deal with such virtual
7282 || IT_STRING_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7284 IT_STRING_BYTEPOS (*it
) += it
->len
;
7285 IT_STRING_CHARPOS (*it
) += 1;
7289 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7291 bidi_move_to_visually_next (&it
->bidi_it
);
7292 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7293 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7294 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7296 ptrdiff_t stop
= it
->end_charpos
;
7298 if (it
->bidi_it
.scan_dir
< 0)
7300 composition_compute_stop_pos (&it
->cmp_it
,
7301 IT_STRING_CHARPOS (*it
),
7302 IT_STRING_BYTEPOS (*it
), stop
,
7308 consider_string_end
:
7310 if (it
->current
.overlay_string_index
>= 0)
7312 /* IT->string is an overlay string. Advance to the
7313 next, if there is one. */
7314 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7317 next_overlay_string (it
);
7319 setup_for_ellipsis (it
, 0);
7324 /* IT->string is not an overlay string. If we reached
7325 its end, and there is something on IT->stack, proceed
7326 with what is on the stack. This can be either another
7327 string, this time an overlay string, or a buffer. */
7328 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
7332 if (it
->method
== GET_FROM_STRING
)
7333 goto consider_string_end
;
7338 case GET_FROM_IMAGE
:
7339 case GET_FROM_STRETCH
:
7340 /* The position etc with which we have to proceed are on
7341 the stack. The position may be at the end of a string,
7342 if the `display' property takes up the whole string. */
7343 eassert (it
->sp
> 0);
7345 if (it
->method
== GET_FROM_STRING
)
7346 goto consider_string_end
;
7350 /* There are no other methods defined, so this should be a bug. */
7354 eassert (it
->method
!= GET_FROM_STRING
7355 || (STRINGP (it
->string
)
7356 && IT_STRING_CHARPOS (*it
) >= 0));
7359 /* Load IT's display element fields with information about the next
7360 display element which comes from a display table entry or from the
7361 result of translating a control character to one of the forms `^C'
7364 IT->dpvec holds the glyphs to return as characters.
7365 IT->saved_face_id holds the face id before the display vector--it
7366 is restored into IT->face_id in set_iterator_to_next. */
7369 next_element_from_display_vector (struct it
*it
)
7374 eassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
7376 it
->face_id
= it
->saved_face_id
;
7378 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
7379 That seemed totally bogus - so I changed it... */
7380 gc
= it
->dpvec
[it
->current
.dpvec_index
];
7382 if (GLYPH_CODE_P (gc
))
7384 it
->c
= GLYPH_CODE_CHAR (gc
);
7385 it
->len
= CHAR_BYTES (it
->c
);
7387 /* The entry may contain a face id to use. Such a face id is
7388 the id of a Lisp face, not a realized face. A face id of
7389 zero means no face is specified. */
7390 if (it
->dpvec_face_id
>= 0)
7391 it
->face_id
= it
->dpvec_face_id
;
7394 int lface_id
= GLYPH_CODE_FACE (gc
);
7396 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
7401 /* Display table entry is invalid. Return a space. */
7402 it
->c
= ' ', it
->len
= 1;
7404 /* Don't change position and object of the iterator here. They are
7405 still the values of the character that had this display table
7406 entry or was translated, and that's what we want. */
7407 it
->what
= IT_CHARACTER
;
7411 /* Get the first element of string/buffer in the visual order, after
7412 being reseated to a new position in a string or a buffer. */
7414 get_visually_first_element (struct it
*it
)
7416 int string_p
= STRINGP (it
->string
) || it
->s
;
7417 ptrdiff_t eob
= (string_p
? it
->bidi_it
.string
.schars
: ZV
);
7418 ptrdiff_t bob
= (string_p
? 0 : BEGV
);
7420 if (STRINGP (it
->string
))
7422 it
->bidi_it
.charpos
= IT_STRING_CHARPOS (*it
);
7423 it
->bidi_it
.bytepos
= IT_STRING_BYTEPOS (*it
);
7427 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
7428 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
7431 if (it
->bidi_it
.charpos
== eob
)
7433 /* Nothing to do, but reset the FIRST_ELT flag, like
7434 bidi_paragraph_init does, because we are not going to
7436 it
->bidi_it
.first_elt
= 0;
7438 else if (it
->bidi_it
.charpos
== bob
7440 && (FETCH_CHAR (it
->bidi_it
.bytepos
- 1) == '\n'
7441 || FETCH_CHAR (it
->bidi_it
.bytepos
) == '\n')))
7443 /* If we are at the beginning of a line/string, we can produce
7444 the next element right away. */
7445 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7446 bidi_move_to_visually_next (&it
->bidi_it
);
7450 ptrdiff_t orig_bytepos
= it
->bidi_it
.bytepos
;
7452 /* We need to prime the bidi iterator starting at the line's or
7453 string's beginning, before we will be able to produce the
7456 it
->bidi_it
.charpos
= it
->bidi_it
.bytepos
= 0;
7459 it
->bidi_it
.charpos
= find_next_newline_no_quit (IT_CHARPOS (*it
),
7461 it
->bidi_it
.bytepos
= CHAR_TO_BYTE (it
->bidi_it
.charpos
);
7463 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7466 /* Now return to buffer/string position where we were asked
7467 to get the next display element, and produce that. */
7468 bidi_move_to_visually_next (&it
->bidi_it
);
7470 while (it
->bidi_it
.bytepos
!= orig_bytepos
7471 && it
->bidi_it
.charpos
< eob
);
7474 /* Adjust IT's position information to where we ended up. */
7475 if (STRINGP (it
->string
))
7477 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7478 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7482 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7483 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7486 if (STRINGP (it
->string
) || !it
->s
)
7488 ptrdiff_t stop
, charpos
, bytepos
;
7490 if (STRINGP (it
->string
))
7493 stop
= SCHARS (it
->string
);
7494 if (stop
> it
->end_charpos
)
7495 stop
= it
->end_charpos
;
7496 charpos
= IT_STRING_CHARPOS (*it
);
7497 bytepos
= IT_STRING_BYTEPOS (*it
);
7501 stop
= it
->end_charpos
;
7502 charpos
= IT_CHARPOS (*it
);
7503 bytepos
= IT_BYTEPOS (*it
);
7505 if (it
->bidi_it
.scan_dir
< 0)
7507 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
, stop
,
7512 /* Load IT with the next display element from Lisp string IT->string.
7513 IT->current.string_pos is the current position within the string.
7514 If IT->current.overlay_string_index >= 0, the Lisp string is an
7518 next_element_from_string (struct it
*it
)
7520 struct text_pos position
;
7522 eassert (STRINGP (it
->string
));
7523 eassert (!it
->bidi_p
|| EQ (it
->string
, it
->bidi_it
.string
.lstring
));
7524 eassert (IT_STRING_CHARPOS (*it
) >= 0);
7525 position
= it
->current
.string_pos
;
7527 /* With bidi reordering, the character to display might not be the
7528 character at IT_STRING_CHARPOS. BIDI_IT.FIRST_ELT non-zero means
7529 that we were reseat()ed to a new string, whose paragraph
7530 direction is not known. */
7531 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7533 get_visually_first_element (it
);
7534 SET_TEXT_POS (position
, IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
));
7537 /* Time to check for invisible text? */
7538 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
7540 if (IT_STRING_CHARPOS (*it
) >= it
->stop_charpos
)
7543 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7544 || IT_STRING_CHARPOS (*it
) == it
->stop_charpos
))
7546 /* With bidi non-linear iteration, we could find
7547 ourselves far beyond the last computed stop_charpos,
7548 with several other stop positions in between that we
7549 missed. Scan them all now, in buffer's logical
7550 order, until we find and handle the last stop_charpos
7551 that precedes our current position. */
7552 handle_stop_backwards (it
, it
->stop_charpos
);
7553 return GET_NEXT_DISPLAY_ELEMENT (it
);
7559 /* Take note of the stop position we just moved
7560 across, for when we will move back across it. */
7561 it
->prev_stop
= it
->stop_charpos
;
7562 /* If we are at base paragraph embedding level, take
7563 note of the last stop position seen at this
7565 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7566 it
->base_level_stop
= it
->stop_charpos
;
7570 /* Since a handler may have changed IT->method, we must
7572 return GET_NEXT_DISPLAY_ELEMENT (it
);
7576 /* If we are before prev_stop, we may have overstepped
7577 on our way backwards a stop_pos, and if so, we need
7578 to handle that stop_pos. */
7579 && IT_STRING_CHARPOS (*it
) < it
->prev_stop
7580 /* We can sometimes back up for reasons that have nothing
7581 to do with bidi reordering. E.g., compositions. The
7582 code below is only needed when we are above the base
7583 embedding level, so test for that explicitly. */
7584 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7586 /* If we lost track of base_level_stop, we have no better
7587 place for handle_stop_backwards to start from than string
7588 beginning. This happens, e.g., when we were reseated to
7589 the previous screenful of text by vertical-motion. */
7590 if (it
->base_level_stop
<= 0
7591 || IT_STRING_CHARPOS (*it
) < it
->base_level_stop
)
7592 it
->base_level_stop
= 0;
7593 handle_stop_backwards (it
, it
->base_level_stop
);
7594 return GET_NEXT_DISPLAY_ELEMENT (it
);
7598 if (it
->current
.overlay_string_index
>= 0)
7600 /* Get the next character from an overlay string. In overlay
7601 strings, there is no field width or padding with spaces to
7603 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7608 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7609 IT_STRING_BYTEPOS (*it
),
7610 it
->bidi_it
.scan_dir
< 0
7612 : SCHARS (it
->string
))
7613 && next_element_from_composition (it
))
7617 else if (STRING_MULTIBYTE (it
->string
))
7619 const unsigned char *s
= (SDATA (it
->string
)
7620 + IT_STRING_BYTEPOS (*it
));
7621 it
->c
= string_char_and_length (s
, &it
->len
);
7625 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7631 /* Get the next character from a Lisp string that is not an
7632 overlay string. Such strings come from the mode line, for
7633 example. We may have to pad with spaces, or truncate the
7634 string. See also next_element_from_c_string. */
7635 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7640 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
7642 /* Pad with spaces. */
7643 it
->c
= ' ', it
->len
= 1;
7644 CHARPOS (position
) = BYTEPOS (position
) = -1;
7646 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7647 IT_STRING_BYTEPOS (*it
),
7648 it
->bidi_it
.scan_dir
< 0
7650 : it
->string_nchars
)
7651 && next_element_from_composition (it
))
7655 else if (STRING_MULTIBYTE (it
->string
))
7657 const unsigned char *s
= (SDATA (it
->string
)
7658 + IT_STRING_BYTEPOS (*it
));
7659 it
->c
= string_char_and_length (s
, &it
->len
);
7663 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7668 /* Record what we have and where it came from. */
7669 it
->what
= IT_CHARACTER
;
7670 it
->object
= it
->string
;
7671 it
->position
= position
;
7676 /* Load IT with next display element from C string IT->s.
7677 IT->string_nchars is the maximum number of characters to return
7678 from the string. IT->end_charpos may be greater than
7679 IT->string_nchars when this function is called, in which case we
7680 may have to return padding spaces. Value is zero if end of string
7681 reached, including padding spaces. */
7684 next_element_from_c_string (struct it
*it
)
7689 eassert (!it
->bidi_p
|| it
->s
== it
->bidi_it
.string
.s
);
7690 it
->what
= IT_CHARACTER
;
7691 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
7694 /* With bidi reordering, the character to display might not be the
7695 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7696 we were reseated to a new string, whose paragraph direction is
7698 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7699 get_visually_first_element (it
);
7701 /* IT's position can be greater than IT->string_nchars in case a
7702 field width or precision has been specified when the iterator was
7704 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7706 /* End of the game. */
7710 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
7712 /* Pad with spaces. */
7713 it
->c
= ' ', it
->len
= 1;
7714 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
7716 else if (it
->multibyte_p
)
7717 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
), &it
->len
);
7719 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
7725 /* Set up IT to return characters from an ellipsis, if appropriate.
7726 The definition of the ellipsis glyphs may come from a display table
7727 entry. This function fills IT with the first glyph from the
7728 ellipsis if an ellipsis is to be displayed. */
7731 next_element_from_ellipsis (struct it
*it
)
7733 if (it
->selective_display_ellipsis_p
)
7734 setup_for_ellipsis (it
, it
->len
);
7737 /* The face at the current position may be different from the
7738 face we find after the invisible text. Remember what it
7739 was in IT->saved_face_id, and signal that it's there by
7740 setting face_before_selective_p. */
7741 it
->saved_face_id
= it
->face_id
;
7742 it
->method
= GET_FROM_BUFFER
;
7743 it
->object
= it
->w
->buffer
;
7744 reseat_at_next_visible_line_start (it
, 1);
7745 it
->face_before_selective_p
= 1;
7748 return GET_NEXT_DISPLAY_ELEMENT (it
);
7752 /* Deliver an image display element. The iterator IT is already
7753 filled with image information (done in handle_display_prop). Value
7758 next_element_from_image (struct it
*it
)
7760 it
->what
= IT_IMAGE
;
7761 it
->ignore_overlay_strings_at_pos_p
= 0;
7766 /* Fill iterator IT with next display element from a stretch glyph
7767 property. IT->object is the value of the text property. Value is
7771 next_element_from_stretch (struct it
*it
)
7773 it
->what
= IT_STRETCH
;
7777 /* Scan backwards from IT's current position until we find a stop
7778 position, or until BEGV. This is called when we find ourself
7779 before both the last known prev_stop and base_level_stop while
7780 reordering bidirectional text. */
7783 compute_stop_pos_backwards (struct it
*it
)
7785 const int SCAN_BACK_LIMIT
= 1000;
7786 struct text_pos pos
;
7787 struct display_pos save_current
= it
->current
;
7788 struct text_pos save_position
= it
->position
;
7789 ptrdiff_t charpos
= IT_CHARPOS (*it
);
7790 ptrdiff_t where_we_are
= charpos
;
7791 ptrdiff_t save_stop_pos
= it
->stop_charpos
;
7792 ptrdiff_t save_end_pos
= it
->end_charpos
;
7794 eassert (NILP (it
->string
) && !it
->s
);
7795 eassert (it
->bidi_p
);
7799 it
->end_charpos
= min (charpos
+ 1, ZV
);
7800 charpos
= max (charpos
- SCAN_BACK_LIMIT
, BEGV
);
7801 SET_TEXT_POS (pos
, charpos
, CHAR_TO_BYTE (charpos
));
7802 reseat_1 (it
, pos
, 0);
7803 compute_stop_pos (it
);
7804 /* We must advance forward, right? */
7805 if (it
->stop_charpos
<= charpos
)
7808 while (charpos
> BEGV
&& it
->stop_charpos
>= it
->end_charpos
);
7810 if (it
->stop_charpos
<= where_we_are
)
7811 it
->prev_stop
= it
->stop_charpos
;
7813 it
->prev_stop
= BEGV
;
7815 it
->current
= save_current
;
7816 it
->position
= save_position
;
7817 it
->stop_charpos
= save_stop_pos
;
7818 it
->end_charpos
= save_end_pos
;
7821 /* Scan forward from CHARPOS in the current buffer/string, until we
7822 find a stop position > current IT's position. Then handle the stop
7823 position before that. This is called when we bump into a stop
7824 position while reordering bidirectional text. CHARPOS should be
7825 the last previously processed stop_pos (or BEGV/0, if none were
7826 processed yet) whose position is less that IT's current
7830 handle_stop_backwards (struct it
*it
, ptrdiff_t charpos
)
7832 int bufp
= !STRINGP (it
->string
);
7833 ptrdiff_t where_we_are
= (bufp
? IT_CHARPOS (*it
) : IT_STRING_CHARPOS (*it
));
7834 struct display_pos save_current
= it
->current
;
7835 struct text_pos save_position
= it
->position
;
7836 struct text_pos pos1
;
7837 ptrdiff_t next_stop
;
7839 /* Scan in strict logical order. */
7840 eassert (it
->bidi_p
);
7844 it
->prev_stop
= charpos
;
7847 SET_TEXT_POS (pos1
, charpos
, CHAR_TO_BYTE (charpos
));
7848 reseat_1 (it
, pos1
, 0);
7851 it
->current
.string_pos
= string_pos (charpos
, it
->string
);
7852 compute_stop_pos (it
);
7853 /* We must advance forward, right? */
7854 if (it
->stop_charpos
<= it
->prev_stop
)
7856 charpos
= it
->stop_charpos
;
7858 while (charpos
<= where_we_are
);
7861 it
->current
= save_current
;
7862 it
->position
= save_position
;
7863 next_stop
= it
->stop_charpos
;
7864 it
->stop_charpos
= it
->prev_stop
;
7866 it
->stop_charpos
= next_stop
;
7869 /* Load IT with the next display element from current_buffer. Value
7870 is zero if end of buffer reached. IT->stop_charpos is the next
7871 position at which to stop and check for text properties or buffer
7875 next_element_from_buffer (struct it
*it
)
7879 eassert (IT_CHARPOS (*it
) >= BEGV
);
7880 eassert (NILP (it
->string
) && !it
->s
);
7881 eassert (!it
->bidi_p
7882 || (EQ (it
->bidi_it
.string
.lstring
, Qnil
)
7883 && it
->bidi_it
.string
.s
== NULL
));
7885 /* With bidi reordering, the character to display might not be the
7886 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7887 we were reseat()ed to a new buffer position, which is potentially
7888 a different paragraph. */
7889 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7891 get_visually_first_element (it
);
7892 SET_TEXT_POS (it
->position
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7895 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
7897 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7899 int overlay_strings_follow_p
;
7901 /* End of the game, except when overlay strings follow that
7902 haven't been returned yet. */
7903 if (it
->overlay_strings_at_end_processed_p
)
7904 overlay_strings_follow_p
= 0;
7907 it
->overlay_strings_at_end_processed_p
= 1;
7908 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
7911 if (overlay_strings_follow_p
)
7912 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
7916 it
->position
= it
->current
.pos
;
7920 else if (!(!it
->bidi_p
7921 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7922 || IT_CHARPOS (*it
) == it
->stop_charpos
))
7924 /* With bidi non-linear iteration, we could find ourselves
7925 far beyond the last computed stop_charpos, with several
7926 other stop positions in between that we missed. Scan
7927 them all now, in buffer's logical order, until we find
7928 and handle the last stop_charpos that precedes our
7929 current position. */
7930 handle_stop_backwards (it
, it
->stop_charpos
);
7931 return GET_NEXT_DISPLAY_ELEMENT (it
);
7937 /* Take note of the stop position we just moved across,
7938 for when we will move back across it. */
7939 it
->prev_stop
= it
->stop_charpos
;
7940 /* If we are at base paragraph embedding level, take
7941 note of the last stop position seen at this
7943 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7944 it
->base_level_stop
= it
->stop_charpos
;
7947 return GET_NEXT_DISPLAY_ELEMENT (it
);
7951 /* If we are before prev_stop, we may have overstepped on
7952 our way backwards a stop_pos, and if so, we need to
7953 handle that stop_pos. */
7954 && IT_CHARPOS (*it
) < it
->prev_stop
7955 /* We can sometimes back up for reasons that have nothing
7956 to do with bidi reordering. E.g., compositions. The
7957 code below is only needed when we are above the base
7958 embedding level, so test for that explicitly. */
7959 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7961 if (it
->base_level_stop
<= 0
7962 || IT_CHARPOS (*it
) < it
->base_level_stop
)
7964 /* If we lost track of base_level_stop, we need to find
7965 prev_stop by looking backwards. This happens, e.g., when
7966 we were reseated to the previous screenful of text by
7968 it
->base_level_stop
= BEGV
;
7969 compute_stop_pos_backwards (it
);
7970 handle_stop_backwards (it
, it
->prev_stop
);
7973 handle_stop_backwards (it
, it
->base_level_stop
);
7974 return GET_NEXT_DISPLAY_ELEMENT (it
);
7978 /* No face changes, overlays etc. in sight, so just return a
7979 character from current_buffer. */
7983 /* Maybe run the redisplay end trigger hook. Performance note:
7984 This doesn't seem to cost measurable time. */
7985 if (it
->redisplay_end_trigger_charpos
7987 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
7988 run_redisplay_end_trigger_hook (it
);
7990 stop
= it
->bidi_it
.scan_dir
< 0 ? -1 : it
->end_charpos
;
7991 if (CHAR_COMPOSED_P (it
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
7993 && next_element_from_composition (it
))
7998 /* Get the next character, maybe multibyte. */
7999 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
8000 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
8001 it
->c
= STRING_CHAR_AND_LENGTH (p
, it
->len
);
8003 it
->c
= *p
, it
->len
= 1;
8005 /* Record what we have and where it came from. */
8006 it
->what
= IT_CHARACTER
;
8007 it
->object
= it
->w
->buffer
;
8008 it
->position
= it
->current
.pos
;
8010 /* Normally we return the character found above, except when we
8011 really want to return an ellipsis for selective display. */
8016 /* A value of selective > 0 means hide lines indented more
8017 than that number of columns. */
8018 if (it
->selective
> 0
8019 && IT_CHARPOS (*it
) + 1 < ZV
8020 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
8021 IT_BYTEPOS (*it
) + 1,
8024 success_p
= next_element_from_ellipsis (it
);
8025 it
->dpvec_char_len
= -1;
8028 else if (it
->c
== '\r' && it
->selective
== -1)
8030 /* A value of selective == -1 means that everything from the
8031 CR to the end of the line is invisible, with maybe an
8032 ellipsis displayed for it. */
8033 success_p
= next_element_from_ellipsis (it
);
8034 it
->dpvec_char_len
= -1;
8039 /* Value is zero if end of buffer reached. */
8040 eassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
8045 /* Run the redisplay end trigger hook for IT. */
8048 run_redisplay_end_trigger_hook (struct it
*it
)
8050 Lisp_Object args
[3];
8052 /* IT->glyph_row should be non-null, i.e. we should be actually
8053 displaying something, or otherwise we should not run the hook. */
8054 eassert (it
->glyph_row
);
8056 /* Set up hook arguments. */
8057 args
[0] = Qredisplay_end_trigger_functions
;
8058 args
[1] = it
->window
;
8059 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
8060 it
->redisplay_end_trigger_charpos
= 0;
8062 /* Since we are *trying* to run these functions, don't try to run
8063 them again, even if they get an error. */
8064 wset_redisplay_end_trigger (it
->w
, Qnil
);
8065 Frun_hook_with_args (3, args
);
8067 /* Notice if it changed the face of the character we are on. */
8068 handle_face_prop (it
);
8072 /* Deliver a composition display element. Unlike the other
8073 next_element_from_XXX, this function is not registered in the array
8074 get_next_element[]. It is called from next_element_from_buffer and
8075 next_element_from_string when necessary. */
8078 next_element_from_composition (struct it
*it
)
8080 it
->what
= IT_COMPOSITION
;
8081 it
->len
= it
->cmp_it
.nbytes
;
8082 if (STRINGP (it
->string
))
8086 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8087 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8090 it
->position
= it
->current
.string_pos
;
8091 it
->object
= it
->string
;
8092 it
->c
= composition_update_it (&it
->cmp_it
, IT_STRING_CHARPOS (*it
),
8093 IT_STRING_BYTEPOS (*it
), it
->string
);
8099 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8100 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8103 if (it
->bidi_it
.new_paragraph
)
8104 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
8105 /* Resync the bidi iterator with IT's new position.
8106 FIXME: this doesn't support bidirectional text. */
8107 while (it
->bidi_it
.charpos
< IT_CHARPOS (*it
))
8108 bidi_move_to_visually_next (&it
->bidi_it
);
8112 it
->position
= it
->current
.pos
;
8113 it
->object
= it
->w
->buffer
;
8114 it
->c
= composition_update_it (&it
->cmp_it
, IT_CHARPOS (*it
),
8115 IT_BYTEPOS (*it
), Qnil
);
8122 /***********************************************************************
8123 Moving an iterator without producing glyphs
8124 ***********************************************************************/
8126 /* Check if iterator is at a position corresponding to a valid buffer
8127 position after some move_it_ call. */
8129 #define IT_POS_VALID_AFTER_MOVE_P(it) \
8130 ((it)->method == GET_FROM_STRING \
8131 ? IT_STRING_CHARPOS (*it) == 0 \
8135 /* Move iterator IT to a specified buffer or X position within one
8136 line on the display without producing glyphs.
8138 OP should be a bit mask including some or all of these bits:
8139 MOVE_TO_X: Stop upon reaching x-position TO_X.
8140 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
8141 Regardless of OP's value, stop upon reaching the end of the display line.
8143 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
8144 This means, in particular, that TO_X includes window's horizontal
8147 The return value has several possible values that
8148 say what condition caused the scan to stop:
8150 MOVE_POS_MATCH_OR_ZV
8151 - when TO_POS or ZV was reached.
8154 -when TO_X was reached before TO_POS or ZV were reached.
8157 - when we reached the end of the display area and the line must
8161 - when we reached the end of the display area and the line is
8165 - when we stopped at a line end, i.e. a newline or a CR and selective
8168 static enum move_it_result
8169 move_it_in_display_line_to (struct it
*it
,
8170 ptrdiff_t to_charpos
, int to_x
,
8171 enum move_operation_enum op
)
8173 enum move_it_result result
= MOVE_UNDEFINED
;
8174 struct glyph_row
*saved_glyph_row
;
8175 struct it wrap_it
, atpos_it
, atx_it
, ppos_it
;
8176 void *wrap_data
= NULL
, *atpos_data
= NULL
, *atx_data
= NULL
;
8177 void *ppos_data
= NULL
;
8179 enum it_method prev_method
= it
->method
;
8180 ptrdiff_t prev_pos
= IT_CHARPOS (*it
);
8181 int saw_smaller_pos
= prev_pos
< to_charpos
;
8183 /* Don't produce glyphs in produce_glyphs. */
8184 saved_glyph_row
= it
->glyph_row
;
8185 it
->glyph_row
= NULL
;
8187 /* Use wrap_it to save a copy of IT wherever a word wrap could
8188 occur. Use atpos_it to save a copy of IT at the desired buffer
8189 position, if found, so that we can scan ahead and check if the
8190 word later overshoots the window edge. Use atx_it similarly, for
8196 /* Use ppos_it under bidi reordering to save a copy of IT for the
8197 position > CHARPOS that is the closest to CHARPOS. We restore
8198 that position in IT when we have scanned the entire display line
8199 without finding a match for CHARPOS and all the character
8200 positions are greater than CHARPOS. */
8203 SAVE_IT (ppos_it
, *it
, ppos_data
);
8204 SET_TEXT_POS (ppos_it
.current
.pos
, ZV
, ZV_BYTE
);
8205 if ((op
& MOVE_TO_POS
) && IT_CHARPOS (*it
) >= to_charpos
)
8206 SAVE_IT (ppos_it
, *it
, ppos_data
);
8209 #define BUFFER_POS_REACHED_P() \
8210 ((op & MOVE_TO_POS) != 0 \
8211 && BUFFERP (it->object) \
8212 && (IT_CHARPOS (*it) == to_charpos \
8214 || BIDI_AT_BASE_LEVEL (it->bidi_it)) \
8215 && IT_CHARPOS (*it) > to_charpos) \
8216 || (it->what == IT_COMPOSITION \
8217 && ((IT_CHARPOS (*it) > to_charpos \
8218 && to_charpos >= it->cmp_it.charpos) \
8219 || (IT_CHARPOS (*it) < to_charpos \
8220 && to_charpos <= it->cmp_it.charpos)))) \
8221 && (it->method == GET_FROM_BUFFER \
8222 || (it->method == GET_FROM_DISPLAY_VECTOR \
8223 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
8225 /* If there's a line-/wrap-prefix, handle it. */
8226 if (it
->hpos
== 0 && it
->method
== GET_FROM_BUFFER
8227 && it
->current_y
< it
->last_visible_y
)
8228 handle_line_prefix (it
);
8230 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8231 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8235 int x
, i
, ascent
= 0, descent
= 0;
8237 /* Utility macro to reset an iterator with x, ascent, and descent. */
8238 #define IT_RESET_X_ASCENT_DESCENT(IT) \
8239 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
8240 (IT)->max_descent = descent)
8242 /* Stop if we move beyond TO_CHARPOS (after an image or a
8243 display string or stretch glyph). */
8244 if ((op
& MOVE_TO_POS
) != 0
8245 && BUFFERP (it
->object
)
8246 && it
->method
== GET_FROM_BUFFER
8248 /* When the iterator is at base embedding level, we
8249 are guaranteed that characters are delivered for
8250 display in strictly increasing order of their
8251 buffer positions. */
8252 || BIDI_AT_BASE_LEVEL (it
->bidi_it
))
8253 && IT_CHARPOS (*it
) > to_charpos
)
8255 && (prev_method
== GET_FROM_IMAGE
8256 || prev_method
== GET_FROM_STRETCH
8257 || prev_method
== GET_FROM_STRING
)
8258 /* Passed TO_CHARPOS from left to right. */
8259 && ((prev_pos
< to_charpos
8260 && IT_CHARPOS (*it
) > to_charpos
)
8261 /* Passed TO_CHARPOS from right to left. */
8262 || (prev_pos
> to_charpos
8263 && IT_CHARPOS (*it
) < to_charpos
)))))
8265 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8267 result
= MOVE_POS_MATCH_OR_ZV
;
8270 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8271 /* If wrap_it is valid, the current position might be in a
8272 word that is wrapped. So, save the iterator in
8273 atpos_it and continue to see if wrapping happens. */
8274 SAVE_IT (atpos_it
, *it
, atpos_data
);
8277 /* Stop when ZV reached.
8278 We used to stop here when TO_CHARPOS reached as well, but that is
8279 too soon if this glyph does not fit on this line. So we handle it
8280 explicitly below. */
8281 if (!get_next_display_element (it
))
8283 result
= MOVE_POS_MATCH_OR_ZV
;
8287 if (it
->line_wrap
== TRUNCATE
)
8289 if (BUFFER_POS_REACHED_P ())
8291 result
= MOVE_POS_MATCH_OR_ZV
;
8297 if (it
->line_wrap
== WORD_WRAP
)
8299 if (IT_DISPLAYING_WHITESPACE (it
))
8303 /* We have reached a glyph that follows one or more
8304 whitespace characters. If the position is
8305 already found, we are done. */
8306 if (atpos_it
.sp
>= 0)
8308 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8309 result
= MOVE_POS_MATCH_OR_ZV
;
8314 RESTORE_IT (it
, &atx_it
, atx_data
);
8315 result
= MOVE_X_REACHED
;
8318 /* Otherwise, we can wrap here. */
8319 SAVE_IT (wrap_it
, *it
, wrap_data
);
8325 /* Remember the line height for the current line, in case
8326 the next element doesn't fit on the line. */
8327 ascent
= it
->max_ascent
;
8328 descent
= it
->max_descent
;
8330 /* The call to produce_glyphs will get the metrics of the
8331 display element IT is loaded with. Record the x-position
8332 before this display element, in case it doesn't fit on the
8336 PRODUCE_GLYPHS (it
);
8338 if (it
->area
!= TEXT_AREA
)
8340 prev_method
= it
->method
;
8341 if (it
->method
== GET_FROM_BUFFER
)
8342 prev_pos
= IT_CHARPOS (*it
);
8343 set_iterator_to_next (it
, 1);
8344 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8345 SET_TEXT_POS (this_line_min_pos
,
8346 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8348 && (op
& MOVE_TO_POS
)
8349 && IT_CHARPOS (*it
) > to_charpos
8350 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
8351 SAVE_IT (ppos_it
, *it
, ppos_data
);
8355 /* The number of glyphs we get back in IT->nglyphs will normally
8356 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
8357 character on a terminal frame, or (iii) a line end. For the
8358 second case, IT->nglyphs - 1 padding glyphs will be present.
8359 (On X frames, there is only one glyph produced for a
8360 composite character.)
8362 The behavior implemented below means, for continuation lines,
8363 that as many spaces of a TAB as fit on the current line are
8364 displayed there. For terminal frames, as many glyphs of a
8365 multi-glyph character are displayed in the current line, too.
8366 This is what the old redisplay code did, and we keep it that
8367 way. Under X, the whole shape of a complex character must
8368 fit on the line or it will be completely displayed in the
8371 Note that both for tabs and padding glyphs, all glyphs have
8375 /* More than one glyph or glyph doesn't fit on line. All
8376 glyphs have the same width. */
8377 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
8379 int x_before_this_char
= x
;
8380 int hpos_before_this_char
= it
->hpos
;
8382 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
8384 new_x
= x
+ single_glyph_width
;
8386 /* We want to leave anything reaching TO_X to the caller. */
8387 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
8389 if (BUFFER_POS_REACHED_P ())
8391 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8392 goto buffer_pos_reached
;
8393 if (atpos_it
.sp
< 0)
8395 SAVE_IT (atpos_it
, *it
, atpos_data
);
8396 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8401 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8404 result
= MOVE_X_REACHED
;
8409 SAVE_IT (atx_it
, *it
, atx_data
);
8410 IT_RESET_X_ASCENT_DESCENT (&atx_it
);
8415 if (/* Lines are continued. */
8416 it
->line_wrap
!= TRUNCATE
8417 && (/* And glyph doesn't fit on the line. */
8418 new_x
> it
->last_visible_x
8419 /* Or it fits exactly and we're on a window
8421 || (new_x
== it
->last_visible_x
8422 && FRAME_WINDOW_P (it
->f
)
8423 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8424 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8425 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
8427 if (/* IT->hpos == 0 means the very first glyph
8428 doesn't fit on the line, e.g. a wide image. */
8430 || (new_x
== it
->last_visible_x
8431 && FRAME_WINDOW_P (it
->f
)))
8434 it
->current_x
= new_x
;
8436 /* The character's last glyph just barely fits
8438 if (i
== it
->nglyphs
- 1)
8440 /* If this is the destination position,
8441 return a position *before* it in this row,
8442 now that we know it fits in this row. */
8443 if (BUFFER_POS_REACHED_P ())
8445 if (it
->line_wrap
!= WORD_WRAP
8448 it
->hpos
= hpos_before_this_char
;
8449 it
->current_x
= x_before_this_char
;
8450 result
= MOVE_POS_MATCH_OR_ZV
;
8453 if (it
->line_wrap
== WORD_WRAP
8456 SAVE_IT (atpos_it
, *it
, atpos_data
);
8457 atpos_it
.current_x
= x_before_this_char
;
8458 atpos_it
.hpos
= hpos_before_this_char
;
8462 prev_method
= it
->method
;
8463 if (it
->method
== GET_FROM_BUFFER
)
8464 prev_pos
= IT_CHARPOS (*it
);
8465 set_iterator_to_next (it
, 1);
8466 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8467 SET_TEXT_POS (this_line_min_pos
,
8468 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8469 /* On graphical terminals, newlines may
8470 "overflow" into the fringe if
8471 overflow-newline-into-fringe is non-nil.
8472 On text terminals, and on graphical
8473 terminals with no right margin, newlines
8474 may overflow into the last glyph on the
8476 if (!FRAME_WINDOW_P (it
->f
)
8478 && it
->bidi_it
.paragraph_dir
== R2L
)
8479 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8480 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8481 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8483 if (!get_next_display_element (it
))
8485 result
= MOVE_POS_MATCH_OR_ZV
;
8488 if (BUFFER_POS_REACHED_P ())
8490 if (ITERATOR_AT_END_OF_LINE_P (it
))
8491 result
= MOVE_POS_MATCH_OR_ZV
;
8493 result
= MOVE_LINE_CONTINUED
;
8496 if (ITERATOR_AT_END_OF_LINE_P (it
))
8498 result
= MOVE_NEWLINE_OR_CR
;
8505 IT_RESET_X_ASCENT_DESCENT (it
);
8507 if (wrap_it
.sp
>= 0)
8509 RESTORE_IT (it
, &wrap_it
, wrap_data
);
8514 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
8516 result
= MOVE_LINE_CONTINUED
;
8520 if (BUFFER_POS_REACHED_P ())
8522 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8523 goto buffer_pos_reached
;
8524 if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8526 SAVE_IT (atpos_it
, *it
, atpos_data
);
8527 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8531 if (new_x
> it
->first_visible_x
)
8533 /* Glyph is visible. Increment number of glyphs that
8534 would be displayed. */
8539 if (result
!= MOVE_UNDEFINED
)
8542 else if (BUFFER_POS_REACHED_P ())
8545 IT_RESET_X_ASCENT_DESCENT (it
);
8546 result
= MOVE_POS_MATCH_OR_ZV
;
8549 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
8551 /* Stop when TO_X specified and reached. This check is
8552 necessary here because of lines consisting of a line end,
8553 only. The line end will not produce any glyphs and we
8554 would never get MOVE_X_REACHED. */
8555 eassert (it
->nglyphs
== 0);
8556 result
= MOVE_X_REACHED
;
8560 /* Is this a line end? If yes, we're done. */
8561 if (ITERATOR_AT_END_OF_LINE_P (it
))
8563 /* If we are past TO_CHARPOS, but never saw any character
8564 positions smaller than TO_CHARPOS, return
8565 MOVE_POS_MATCH_OR_ZV, like the unidirectional display
8567 if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0)
8569 if (!saw_smaller_pos
&& IT_CHARPOS (*it
) > to_charpos
)
8571 if (IT_CHARPOS (ppos_it
) < ZV
)
8573 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8574 result
= MOVE_POS_MATCH_OR_ZV
;
8577 goto buffer_pos_reached
;
8579 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
>= 0
8580 && IT_CHARPOS (*it
) > to_charpos
)
8581 goto buffer_pos_reached
;
8583 result
= MOVE_NEWLINE_OR_CR
;
8586 result
= MOVE_NEWLINE_OR_CR
;
8590 prev_method
= it
->method
;
8591 if (it
->method
== GET_FROM_BUFFER
)
8592 prev_pos
= IT_CHARPOS (*it
);
8593 /* The current display element has been consumed. Advance
8595 set_iterator_to_next (it
, 1);
8596 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8597 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8598 if (IT_CHARPOS (*it
) < to_charpos
)
8599 saw_smaller_pos
= 1;
8601 && (op
& MOVE_TO_POS
)
8602 && IT_CHARPOS (*it
) >= to_charpos
8603 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
8604 SAVE_IT (ppos_it
, *it
, ppos_data
);
8606 /* Stop if lines are truncated and IT's current x-position is
8607 past the right edge of the window now. */
8608 if (it
->line_wrap
== TRUNCATE
8609 && it
->current_x
>= it
->last_visible_x
)
8611 if (!FRAME_WINDOW_P (it
->f
)
8612 || ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8613 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8614 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8615 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8619 if ((at_eob_p
= !get_next_display_element (it
))
8620 || BUFFER_POS_REACHED_P ()
8621 /* If we are past TO_CHARPOS, but never saw any
8622 character positions smaller than TO_CHARPOS,
8623 return MOVE_POS_MATCH_OR_ZV, like the
8624 unidirectional display did. */
8625 || (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8627 && IT_CHARPOS (*it
) > to_charpos
))
8630 && !at_eob_p
&& IT_CHARPOS (ppos_it
) < ZV
)
8631 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8632 result
= MOVE_POS_MATCH_OR_ZV
;
8635 if (ITERATOR_AT_END_OF_LINE_P (it
))
8637 result
= MOVE_NEWLINE_OR_CR
;
8641 else if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8643 && IT_CHARPOS (*it
) > to_charpos
)
8645 if (IT_CHARPOS (ppos_it
) < ZV
)
8646 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8647 result
= MOVE_POS_MATCH_OR_ZV
;
8650 result
= MOVE_LINE_TRUNCATED
;
8653 #undef IT_RESET_X_ASCENT_DESCENT
8656 #undef BUFFER_POS_REACHED_P
8658 /* If we scanned beyond to_pos and didn't find a point to wrap at,
8659 restore the saved iterator. */
8660 if (atpos_it
.sp
>= 0)
8661 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8662 else if (atx_it
.sp
>= 0)
8663 RESTORE_IT (it
, &atx_it
, atx_data
);
8668 bidi_unshelve_cache (atpos_data
, 1);
8670 bidi_unshelve_cache (atx_data
, 1);
8672 bidi_unshelve_cache (wrap_data
, 1);
8674 bidi_unshelve_cache (ppos_data
, 1);
8676 /* Restore the iterator settings altered at the beginning of this
8678 it
->glyph_row
= saved_glyph_row
;
8682 /* For external use. */
8684 move_it_in_display_line (struct it
*it
,
8685 ptrdiff_t to_charpos
, int to_x
,
8686 enum move_operation_enum op
)
8688 if (it
->line_wrap
== WORD_WRAP
8689 && (op
& MOVE_TO_X
))
8692 void *save_data
= NULL
;
8695 SAVE_IT (save_it
, *it
, save_data
);
8696 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8697 /* When word-wrap is on, TO_X may lie past the end
8698 of a wrapped line. Then it->current is the
8699 character on the next line, so backtrack to the
8700 space before the wrap point. */
8701 if (skip
== MOVE_LINE_CONTINUED
)
8703 int prev_x
= max (it
->current_x
- 1, 0);
8704 RESTORE_IT (it
, &save_it
, save_data
);
8705 move_it_in_display_line_to
8706 (it
, -1, prev_x
, MOVE_TO_X
);
8709 bidi_unshelve_cache (save_data
, 1);
8712 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8716 /* Move IT forward until it satisfies one or more of the criteria in
8717 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
8719 OP is a bit-mask that specifies where to stop, and in particular,
8720 which of those four position arguments makes a difference. See the
8721 description of enum move_operation_enum.
8723 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
8724 screen line, this function will set IT to the next position that is
8725 displayed to the right of TO_CHARPOS on the screen. */
8728 move_it_to (struct it
*it
, ptrdiff_t to_charpos
, int to_x
, int to_y
, int to_vpos
, int op
)
8730 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
8731 int line_height
, line_start_x
= 0, reached
= 0;
8732 void *backup_data
= NULL
;
8736 if (op
& MOVE_TO_VPOS
)
8738 /* If no TO_CHARPOS and no TO_X specified, stop at the
8739 start of the line TO_VPOS. */
8740 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
8742 if (it
->vpos
== to_vpos
)
8748 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
8752 /* TO_VPOS >= 0 means stop at TO_X in the line at
8753 TO_VPOS, or at TO_POS, whichever comes first. */
8754 if (it
->vpos
== to_vpos
)
8760 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8762 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
8767 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
8769 /* We have reached TO_X but not in the line we want. */
8770 skip
= move_it_in_display_line_to (it
, to_charpos
,
8772 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8780 else if (op
& MOVE_TO_Y
)
8782 struct it it_backup
;
8784 if (it
->line_wrap
== WORD_WRAP
)
8785 SAVE_IT (it_backup
, *it
, backup_data
);
8787 /* TO_Y specified means stop at TO_X in the line containing
8788 TO_Y---or at TO_CHARPOS if this is reached first. The
8789 problem is that we can't really tell whether the line
8790 contains TO_Y before we have completely scanned it, and
8791 this may skip past TO_X. What we do is to first scan to
8794 If TO_X is not specified, use a TO_X of zero. The reason
8795 is to make the outcome of this function more predictable.
8796 If we didn't use TO_X == 0, we would stop at the end of
8797 the line which is probably not what a caller would expect
8799 skip
= move_it_in_display_line_to
8800 (it
, to_charpos
, ((op
& MOVE_TO_X
) ? to_x
: 0),
8801 (MOVE_TO_X
| (op
& MOVE_TO_POS
)));
8803 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
8804 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8806 else if (skip
== MOVE_X_REACHED
)
8808 /* If TO_X was reached, we want to know whether TO_Y is
8809 in the line. We know this is the case if the already
8810 scanned glyphs make the line tall enough. Otherwise,
8811 we must check by scanning the rest of the line. */
8812 line_height
= it
->max_ascent
+ it
->max_descent
;
8813 if (to_y
>= it
->current_y
8814 && to_y
< it
->current_y
+ line_height
)
8819 SAVE_IT (it_backup
, *it
, backup_data
);
8820 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
8821 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
8823 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
8824 line_height
= it
->max_ascent
+ it
->max_descent
;
8825 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8827 if (to_y
>= it
->current_y
8828 && to_y
< it
->current_y
+ line_height
)
8830 /* If TO_Y is in this line and TO_X was reached
8831 above, we scanned too far. We have to restore
8832 IT's settings to the ones before skipping. But
8833 keep the more accurate values of max_ascent and
8834 max_descent we've found while skipping the rest
8835 of the line, for the sake of callers, such as
8836 pos_visible_p, that need to know the line
8838 int max_ascent
= it
->max_ascent
;
8839 int max_descent
= it
->max_descent
;
8841 RESTORE_IT (it
, &it_backup
, backup_data
);
8842 it
->max_ascent
= max_ascent
;
8843 it
->max_descent
= max_descent
;
8849 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8855 /* Check whether TO_Y is in this line. */
8856 line_height
= it
->max_ascent
+ it
->max_descent
;
8857 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8859 if (to_y
>= it
->current_y
8860 && to_y
< it
->current_y
+ line_height
)
8862 /* When word-wrap is on, TO_X may lie past the end
8863 of a wrapped line. Then it->current is the
8864 character on the next line, so backtrack to the
8865 space before the wrap point. */
8866 if (skip
== MOVE_LINE_CONTINUED
8867 && it
->line_wrap
== WORD_WRAP
)
8869 int prev_x
= max (it
->current_x
- 1, 0);
8870 RESTORE_IT (it
, &it_backup
, backup_data
);
8871 skip
= move_it_in_display_line_to
8872 (it
, -1, prev_x
, MOVE_TO_X
);
8881 else if (BUFFERP (it
->object
)
8882 && (it
->method
== GET_FROM_BUFFER
8883 || it
->method
== GET_FROM_STRETCH
)
8884 && IT_CHARPOS (*it
) >= to_charpos
8885 /* Under bidi iteration, a call to set_iterator_to_next
8886 can scan far beyond to_charpos if the initial
8887 portion of the next line needs to be reordered. In
8888 that case, give move_it_in_display_line_to another
8891 && it
->bidi_it
.scan_dir
== -1))
8892 skip
= MOVE_POS_MATCH_OR_ZV
;
8894 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
8898 case MOVE_POS_MATCH_OR_ZV
:
8902 case MOVE_NEWLINE_OR_CR
:
8903 set_iterator_to_next (it
, 1);
8904 it
->continuation_lines_width
= 0;
8907 case MOVE_LINE_TRUNCATED
:
8908 it
->continuation_lines_width
= 0;
8909 reseat_at_next_visible_line_start (it
, 0);
8910 if ((op
& MOVE_TO_POS
) != 0
8911 && IT_CHARPOS (*it
) > to_charpos
)
8918 case MOVE_LINE_CONTINUED
:
8919 /* For continued lines ending in a tab, some of the glyphs
8920 associated with the tab are displayed on the current
8921 line. Since it->current_x does not include these glyphs,
8922 we use it->last_visible_x instead. */
8925 it
->continuation_lines_width
+= it
->last_visible_x
;
8926 /* When moving by vpos, ensure that the iterator really
8927 advances to the next line (bug#847, bug#969). Fixme:
8928 do we need to do this in other circumstances? */
8929 if (it
->current_x
!= it
->last_visible_x
8930 && (op
& MOVE_TO_VPOS
)
8931 && !(op
& (MOVE_TO_X
| MOVE_TO_POS
)))
8933 line_start_x
= it
->current_x
+ it
->pixel_width
8934 - it
->last_visible_x
;
8935 set_iterator_to_next (it
, 0);
8939 it
->continuation_lines_width
+= it
->current_x
;
8946 /* Reset/increment for the next run. */
8947 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
8948 it
->current_x
= line_start_x
;
8951 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8953 last_height
= it
->max_ascent
+ it
->max_descent
;
8954 last_max_ascent
= it
->max_ascent
;
8955 it
->max_ascent
= it
->max_descent
= 0;
8960 /* On text terminals, we may stop at the end of a line in the middle
8961 of a multi-character glyph. If the glyph itself is continued,
8962 i.e. it is actually displayed on the next line, don't treat this
8963 stopping point as valid; move to the next line instead (unless
8964 that brings us offscreen). */
8965 if (!FRAME_WINDOW_P (it
->f
)
8967 && IT_CHARPOS (*it
) == to_charpos
8968 && it
->what
== IT_CHARACTER
8970 && it
->line_wrap
== WINDOW_WRAP
8971 && it
->current_x
== it
->last_visible_x
- 1
8974 && it
->vpos
< XFASTINT (it
->w
->window_end_vpos
))
8976 it
->continuation_lines_width
+= it
->current_x
;
8977 it
->current_x
= it
->hpos
= it
->max_ascent
= it
->max_descent
= 0;
8978 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8980 last_height
= it
->max_ascent
+ it
->max_descent
;
8981 last_max_ascent
= it
->max_ascent
;
8985 bidi_unshelve_cache (backup_data
, 1);
8987 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
8991 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
8993 If DY > 0, move IT backward at least that many pixels. DY = 0
8994 means move IT backward to the preceding line start or BEGV. This
8995 function may move over more than DY pixels if IT->current_y - DY
8996 ends up in the middle of a line; in this case IT->current_y will be
8997 set to the top of the line moved to. */
9000 move_it_vertically_backward (struct it
*it
, int dy
)
9004 void *it2data
= NULL
, *it3data
= NULL
;
9005 ptrdiff_t start_pos
;
9010 start_pos
= IT_CHARPOS (*it
);
9012 /* Estimate how many newlines we must move back. */
9013 nlines
= max (1, dy
/ FRAME_LINE_HEIGHT (it
->f
));
9015 /* Set the iterator's position that many lines back. */
9016 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
9017 back_to_previous_visible_line_start (it
);
9019 /* Reseat the iterator here. When moving backward, we don't want
9020 reseat to skip forward over invisible text, set up the iterator
9021 to deliver from overlay strings at the new position etc. So,
9022 use reseat_1 here. */
9023 reseat_1 (it
, it
->current
.pos
, 1);
9025 /* We are now surely at a line start. */
9026 it
->current_x
= it
->hpos
= 0; /* FIXME: this is incorrect when bidi
9027 reordering is in effect. */
9028 it
->continuation_lines_width
= 0;
9030 /* Move forward and see what y-distance we moved. First move to the
9031 start of the next line so that we get its height. We need this
9032 height to be able to tell whether we reached the specified
9034 SAVE_IT (it2
, *it
, it2data
);
9035 it2
.max_ascent
= it2
.max_descent
= 0;
9038 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
9039 MOVE_TO_POS
| MOVE_TO_VPOS
);
9041 while (!(IT_POS_VALID_AFTER_MOVE_P (&it2
)
9042 /* If we are in a display string which starts at START_POS,
9043 and that display string includes a newline, and we are
9044 right after that newline (i.e. at the beginning of a
9045 display line), exit the loop, because otherwise we will
9046 infloop, since move_it_to will see that it is already at
9047 START_POS and will not move. */
9048 || (it2
.method
== GET_FROM_STRING
9049 && IT_CHARPOS (it2
) == start_pos
9050 && SREF (it2
.string
, IT_STRING_BYTEPOS (it2
) - 1) == '\n')));
9051 eassert (IT_CHARPOS (*it
) >= BEGV
);
9052 SAVE_IT (it3
, it2
, it3data
);
9054 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
9055 eassert (IT_CHARPOS (*it
) >= BEGV
);
9056 /* H is the actual vertical distance from the position in *IT
9057 and the starting position. */
9058 h
= it2
.current_y
- it
->current_y
;
9059 /* NLINES is the distance in number of lines. */
9060 nlines
= it2
.vpos
- it
->vpos
;
9062 /* Correct IT's y and vpos position
9063 so that they are relative to the starting point. */
9069 /* DY == 0 means move to the start of the screen line. The
9070 value of nlines is > 0 if continuation lines were involved,
9071 or if the original IT position was at start of a line. */
9072 RESTORE_IT (it
, it
, it2data
);
9074 move_it_by_lines (it
, nlines
);
9075 /* The above code moves us to some position NLINES down,
9076 usually to its first glyph (leftmost in an L2R line), but
9077 that's not necessarily the start of the line, under bidi
9078 reordering. We want to get to the character position
9079 that is immediately after the newline of the previous
9082 && !it
->continuation_lines_width
9083 && !STRINGP (it
->string
)
9084 && IT_CHARPOS (*it
) > BEGV
9085 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9088 find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
9090 move_it_to (it
, nl_pos
, -1, -1, -1, MOVE_TO_POS
);
9092 bidi_unshelve_cache (it3data
, 1);
9096 /* The y-position we try to reach, relative to *IT.
9097 Note that H has been subtracted in front of the if-statement. */
9098 int target_y
= it
->current_y
+ h
- dy
;
9099 int y0
= it3
.current_y
;
9103 RESTORE_IT (&it3
, &it3
, it3data
);
9104 y1
= line_bottom_y (&it3
);
9105 line_height
= y1
- y0
;
9106 RESTORE_IT (it
, it
, it2data
);
9107 /* If we did not reach target_y, try to move further backward if
9108 we can. If we moved too far backward, try to move forward. */
9109 if (target_y
< it
->current_y
9110 /* This is heuristic. In a window that's 3 lines high, with
9111 a line height of 13 pixels each, recentering with point
9112 on the bottom line will try to move -39/2 = 19 pixels
9113 backward. Try to avoid moving into the first line. */
9114 && (it
->current_y
- target_y
9115 > min (window_box_height (it
->w
), line_height
* 2 / 3))
9116 && IT_CHARPOS (*it
) > BEGV
)
9118 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
9119 target_y
- it
->current_y
));
9120 dy
= it
->current_y
- target_y
;
9121 goto move_further_back
;
9123 else if (target_y
>= it
->current_y
+ line_height
9124 && IT_CHARPOS (*it
) < ZV
)
9126 /* Should move forward by at least one line, maybe more.
9128 Note: Calling move_it_by_lines can be expensive on
9129 terminal frames, where compute_motion is used (via
9130 vmotion) to do the job, when there are very long lines
9131 and truncate-lines is nil. That's the reason for
9132 treating terminal frames specially here. */
9134 if (!FRAME_WINDOW_P (it
->f
))
9135 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
9140 move_it_by_lines (it
, 1);
9142 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
9149 /* Move IT by a specified amount of pixel lines DY. DY negative means
9150 move backwards. DY = 0 means move to start of screen line. At the
9151 end, IT will be on the start of a screen line. */
9154 move_it_vertically (struct it
*it
, int dy
)
9157 move_it_vertically_backward (it
, -dy
);
9160 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
9161 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
9162 MOVE_TO_POS
| MOVE_TO_Y
);
9163 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
9165 /* If buffer ends in ZV without a newline, move to the start of
9166 the line to satisfy the post-condition. */
9167 if (IT_CHARPOS (*it
) == ZV
9169 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9170 move_it_by_lines (it
, 0);
9175 /* Move iterator IT past the end of the text line it is in. */
9178 move_it_past_eol (struct it
*it
)
9180 enum move_it_result rc
;
9182 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
9183 if (rc
== MOVE_NEWLINE_OR_CR
)
9184 set_iterator_to_next (it
, 0);
9188 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
9189 negative means move up. DVPOS == 0 means move to the start of the
9192 Optimization idea: If we would know that IT->f doesn't use
9193 a face with proportional font, we could be faster for
9194 truncate-lines nil. */
9197 move_it_by_lines (struct it
*it
, ptrdiff_t dvpos
)
9200 /* The commented-out optimization uses vmotion on terminals. This
9201 gives bad results, because elements like it->what, on which
9202 callers such as pos_visible_p rely, aren't updated. */
9203 /* struct position pos;
9204 if (!FRAME_WINDOW_P (it->f))
9206 struct text_pos textpos;
9208 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
9209 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
9210 reseat (it, textpos, 1);
9211 it->vpos += pos.vpos;
9212 it->current_y += pos.vpos;
9218 /* DVPOS == 0 means move to the start of the screen line. */
9219 move_it_vertically_backward (it
, 0);
9220 /* Let next call to line_bottom_y calculate real line height */
9225 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
9226 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
9228 /* Only move to the next buffer position if we ended up in a
9229 string from display property, not in an overlay string
9230 (before-string or after-string). That is because the
9231 latter don't conceal the underlying buffer position, so
9232 we can ask to move the iterator to the exact position we
9233 are interested in. Note that, even if we are already at
9234 IT_CHARPOS (*it), the call below is not a no-op, as it
9235 will detect that we are at the end of the string, pop the
9236 iterator, and compute it->current_x and it->hpos
9238 move_it_to (it
, IT_CHARPOS (*it
) + it
->string_from_display_prop_p
,
9239 -1, -1, -1, MOVE_TO_POS
);
9245 void *it2data
= NULL
;
9246 ptrdiff_t start_charpos
, i
;
9248 /* Start at the beginning of the screen line containing IT's
9249 position. This may actually move vertically backwards,
9250 in case of overlays, so adjust dvpos accordingly. */
9252 move_it_vertically_backward (it
, 0);
9255 /* Go back -DVPOS visible lines and reseat the iterator there. */
9256 start_charpos
= IT_CHARPOS (*it
);
9257 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > BEGV
; --i
)
9258 back_to_previous_visible_line_start (it
);
9259 reseat (it
, it
->current
.pos
, 1);
9261 /* Move further back if we end up in a string or an image. */
9262 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
9264 /* First try to move to start of display line. */
9266 move_it_vertically_backward (it
, 0);
9268 if (IT_POS_VALID_AFTER_MOVE_P (it
))
9270 /* If start of line is still in string or image,
9271 move further back. */
9272 back_to_previous_visible_line_start (it
);
9273 reseat (it
, it
->current
.pos
, 1);
9277 it
->current_x
= it
->hpos
= 0;
9279 /* Above call may have moved too far if continuation lines
9280 are involved. Scan forward and see if it did. */
9281 SAVE_IT (it2
, *it
, it2data
);
9282 it2
.vpos
= it2
.current_y
= 0;
9283 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
9284 it
->vpos
-= it2
.vpos
;
9285 it
->current_y
-= it2
.current_y
;
9286 it
->current_x
= it
->hpos
= 0;
9288 /* If we moved too far back, move IT some lines forward. */
9289 if (it2
.vpos
> -dvpos
)
9291 int delta
= it2
.vpos
+ dvpos
;
9293 RESTORE_IT (&it2
, &it2
, it2data
);
9294 SAVE_IT (it2
, *it
, it2data
);
9295 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
9296 /* Move back again if we got too far ahead. */
9297 if (IT_CHARPOS (*it
) >= start_charpos
)
9298 RESTORE_IT (it
, &it2
, it2data
);
9300 bidi_unshelve_cache (it2data
, 1);
9303 RESTORE_IT (it
, it
, it2data
);
9307 /* Return 1 if IT points into the middle of a display vector. */
9310 in_display_vector_p (struct it
*it
)
9312 return (it
->method
== GET_FROM_DISPLAY_VECTOR
9313 && it
->current
.dpvec_index
> 0
9314 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
9318 /***********************************************************************
9320 ***********************************************************************/
9323 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
9327 add_to_log (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
9329 Lisp_Object args
[3];
9330 Lisp_Object msg
, fmt
;
9333 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9337 GCPRO4 (fmt
, msg
, arg1
, arg2
);
9339 args
[0] = fmt
= build_string (format
);
9342 msg
= Fformat (3, args
);
9344 len
= SBYTES (msg
) + 1;
9345 buffer
= SAFE_ALLOCA (len
);
9346 memcpy (buffer
, SDATA (msg
), len
);
9348 message_dolog (buffer
, len
- 1, 1, 0);
9355 /* Output a newline in the *Messages* buffer if "needs" one. */
9358 message_log_maybe_newline (void)
9360 if (message_log_need_newline
)
9361 message_dolog ("", 0, 1, 0);
9365 /* Add a string M of length NBYTES to the message log, optionally
9366 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
9367 nonzero, means interpret the contents of M as multibyte. This
9368 function calls low-level routines in order to bypass text property
9369 hooks, etc. which might not be safe to run.
9371 This may GC (insert may run before/after change hooks),
9372 so the buffer M must NOT point to a Lisp string. */
9375 message_dolog (const char *m
, ptrdiff_t nbytes
, int nlflag
, int multibyte
)
9377 const unsigned char *msg
= (const unsigned char *) m
;
9379 if (!NILP (Vmemory_full
))
9382 if (!NILP (Vmessage_log_max
))
9384 struct buffer
*oldbuf
;
9385 Lisp_Object oldpoint
, oldbegv
, oldzv
;
9386 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
9387 ptrdiff_t point_at_end
= 0;
9388 ptrdiff_t zv_at_end
= 0;
9389 Lisp_Object old_deactivate_mark
, tem
;
9390 struct gcpro gcpro1
;
9392 old_deactivate_mark
= Vdeactivate_mark
;
9393 oldbuf
= current_buffer
;
9394 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
9395 bset_undo_list (current_buffer
, Qt
);
9397 oldpoint
= message_dolog_marker1
;
9398 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
9399 oldbegv
= message_dolog_marker2
;
9400 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
9401 oldzv
= message_dolog_marker3
;
9402 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
9403 GCPRO1 (old_deactivate_mark
);
9411 BEGV_BYTE
= BEG_BYTE
;
9414 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
9416 /* Insert the string--maybe converting multibyte to single byte
9417 or vice versa, so that all the text fits the buffer. */
9419 && NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9425 /* Convert a multibyte string to single-byte
9426 for the *Message* buffer. */
9427 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
9429 c
= string_char_and_length (msg
+ i
, &char_bytes
);
9430 work
[0] = (ASCII_CHAR_P (c
)
9432 : multibyte_char_to_unibyte (c
));
9433 insert_1_both (work
, 1, 1, 1, 0, 0);
9436 else if (! multibyte
9437 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9441 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
9442 /* Convert a single-byte string to multibyte
9443 for the *Message* buffer. */
9444 for (i
= 0; i
< nbytes
; i
++)
9447 MAKE_CHAR_MULTIBYTE (c
);
9448 char_bytes
= CHAR_STRING (c
, str
);
9449 insert_1_both ((char *) str
, 1, char_bytes
, 1, 0, 0);
9453 insert_1 (m
, nbytes
, 1, 0, 0);
9457 ptrdiff_t this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
;
9459 insert_1 ("\n", 1, 1, 0, 0);
9461 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9463 this_bol_byte
= PT_BYTE
;
9465 /* See if this line duplicates the previous one.
9466 If so, combine duplicates. */
9469 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9471 prev_bol_byte
= PT_BYTE
;
9473 dups
= message_log_check_duplicate (prev_bol_byte
,
9477 del_range_both (prev_bol
, prev_bol_byte
,
9478 this_bol
, this_bol_byte
, 0);
9481 char dupstr
[sizeof " [ times]"
9482 + INT_STRLEN_BOUND (printmax_t
)];
9484 /* If you change this format, don't forget to also
9485 change message_log_check_duplicate. */
9486 int duplen
= sprintf (dupstr
, " [%"pMd
" times]", dups
);
9487 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
9488 insert_1 (dupstr
, duplen
, 1, 0, 1);
9493 /* If we have more than the desired maximum number of lines
9494 in the *Messages* buffer now, delete the oldest ones.
9495 This is safe because we don't have undo in this buffer. */
9497 if (NATNUMP (Vmessage_log_max
))
9499 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
9500 -XFASTINT (Vmessage_log_max
) - 1, 0);
9501 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
9504 BEGV
= XMARKER (oldbegv
)->charpos
;
9505 BEGV_BYTE
= marker_byte_position (oldbegv
);
9514 ZV
= XMARKER (oldzv
)->charpos
;
9515 ZV_BYTE
= marker_byte_position (oldzv
);
9519 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
9521 /* We can't do Fgoto_char (oldpoint) because it will run some
9523 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
9524 XMARKER (oldpoint
)->bytepos
);
9527 unchain_marker (XMARKER (oldpoint
));
9528 unchain_marker (XMARKER (oldbegv
));
9529 unchain_marker (XMARKER (oldzv
));
9531 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
9532 set_buffer_internal (oldbuf
);
9534 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
9535 message_log_need_newline
= !nlflag
;
9536 Vdeactivate_mark
= old_deactivate_mark
;
9541 /* We are at the end of the buffer after just having inserted a newline.
9542 (Note: We depend on the fact we won't be crossing the gap.)
9543 Check to see if the most recent message looks a lot like the previous one.
9544 Return 0 if different, 1 if the new one should just replace it, or a
9545 value N > 1 if we should also append " [N times]". */
9548 message_log_check_duplicate (ptrdiff_t prev_bol_byte
, ptrdiff_t this_bol_byte
)
9551 ptrdiff_t len
= Z_BYTE
- 1 - this_bol_byte
;
9553 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
9554 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
9556 for (i
= 0; i
< len
; i
++)
9558 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
9566 if (*p1
++ == ' ' && *p1
++ == '[')
9569 intmax_t n
= strtoimax ((char *) p1
, &pend
, 10);
9570 if (0 < n
&& n
< INTMAX_MAX
&& strncmp (pend
, " times]\n", 8) == 0)
9577 /* Display an echo area message M with a specified length of NBYTES
9578 bytes. The string may include null characters. If M is 0, clear
9579 out any existing message, and let the mini-buffer text show
9582 This may GC, so the buffer M must NOT point to a Lisp string. */
9585 message2 (const char *m
, ptrdiff_t nbytes
, int multibyte
)
9587 /* First flush out any partial line written with print. */
9588 message_log_maybe_newline ();
9590 message_dolog (m
, nbytes
, 1, multibyte
);
9591 message2_nolog (m
, nbytes
, multibyte
);
9595 /* The non-logging counterpart of message2. */
9598 message2_nolog (const char *m
, ptrdiff_t nbytes
, int multibyte
)
9600 struct frame
*sf
= SELECTED_FRAME ();
9601 message_enable_multibyte
= multibyte
;
9603 if (FRAME_INITIAL_P (sf
))
9605 if (noninteractive_need_newline
)
9606 putc ('\n', stderr
);
9607 noninteractive_need_newline
= 0;
9609 fwrite (m
, nbytes
, 1, stderr
);
9610 if (cursor_in_echo_area
== 0)
9611 fprintf (stderr
, "\n");
9614 /* A null message buffer means that the frame hasn't really been
9615 initialized yet. Error messages get reported properly by
9616 cmd_error, so this must be just an informative message; toss it. */
9617 else if (INTERACTIVE
9618 && sf
->glyphs_initialized_p
9619 && FRAME_MESSAGE_BUF (sf
))
9621 Lisp_Object mini_window
;
9624 /* Get the frame containing the mini-buffer
9625 that the selected frame is using. */
9626 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9627 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9629 FRAME_SAMPLE_VISIBILITY (f
);
9630 if (FRAME_VISIBLE_P (sf
)
9631 && ! FRAME_VISIBLE_P (f
))
9632 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
9636 set_message (m
, Qnil
, nbytes
, multibyte
);
9637 if (minibuffer_auto_raise
)
9638 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
9641 clear_message (1, 1);
9643 do_pending_window_change (0);
9644 echo_area_display (1);
9645 do_pending_window_change (0);
9646 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
9647 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9652 /* Display an echo area message M with a specified length of NBYTES
9653 bytes. The string may include null characters. If M is not a
9654 string, clear out any existing message, and let the mini-buffer
9657 This function cancels echoing. */
9660 message3 (Lisp_Object m
, ptrdiff_t nbytes
, int multibyte
)
9662 struct gcpro gcpro1
;
9665 clear_message (1,1);
9668 /* First flush out any partial line written with print. */
9669 message_log_maybe_newline ();
9673 char *buffer
= SAFE_ALLOCA (nbytes
);
9674 memcpy (buffer
, SDATA (m
), nbytes
);
9675 message_dolog (buffer
, nbytes
, 1, multibyte
);
9678 message3_nolog (m
, nbytes
, multibyte
);
9684 /* The non-logging version of message3.
9685 This does not cancel echoing, because it is used for echoing.
9686 Perhaps we need to make a separate function for echoing
9687 and make this cancel echoing. */
9690 message3_nolog (Lisp_Object m
, ptrdiff_t nbytes
, int multibyte
)
9692 struct frame
*sf
= SELECTED_FRAME ();
9693 message_enable_multibyte
= multibyte
;
9695 if (FRAME_INITIAL_P (sf
))
9697 if (noninteractive_need_newline
)
9698 putc ('\n', stderr
);
9699 noninteractive_need_newline
= 0;
9701 fwrite (SDATA (m
), nbytes
, 1, stderr
);
9702 if (cursor_in_echo_area
== 0)
9703 fprintf (stderr
, "\n");
9706 /* A null message buffer means that the frame hasn't really been
9707 initialized yet. Error messages get reported properly by
9708 cmd_error, so this must be just an informative message; toss it. */
9709 else if (INTERACTIVE
9710 && sf
->glyphs_initialized_p
9711 && FRAME_MESSAGE_BUF (sf
))
9713 Lisp_Object mini_window
;
9717 /* Get the frame containing the mini-buffer
9718 that the selected frame is using. */
9719 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9720 frame
= XWINDOW (mini_window
)->frame
;
9723 FRAME_SAMPLE_VISIBILITY (f
);
9724 if (FRAME_VISIBLE_P (sf
)
9725 && !FRAME_VISIBLE_P (f
))
9726 Fmake_frame_visible (frame
);
9728 if (STRINGP (m
) && SCHARS (m
) > 0)
9730 set_message (NULL
, m
, nbytes
, multibyte
);
9731 if (minibuffer_auto_raise
)
9732 Fraise_frame (frame
);
9733 /* Assume we are not echoing.
9734 (If we are, echo_now will override this.) */
9735 echo_message_buffer
= Qnil
;
9738 clear_message (1, 1);
9740 do_pending_window_change (0);
9741 echo_area_display (1);
9742 do_pending_window_change (0);
9743 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
9744 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9749 /* Display a null-terminated echo area message M. If M is 0, clear
9750 out any existing message, and let the mini-buffer text show through.
9752 The buffer M must continue to exist until after the echo area gets
9753 cleared or some other message gets displayed there. Do not pass
9754 text that is stored in a Lisp string. Do not pass text in a buffer
9755 that was alloca'd. */
9758 message1 (const char *m
)
9760 message2 (m
, (m
? strlen (m
) : 0), 0);
9764 /* The non-logging counterpart of message1. */
9767 message1_nolog (const char *m
)
9769 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
9772 /* Display a message M which contains a single %s
9773 which gets replaced with STRING. */
9776 message_with_string (const char *m
, Lisp_Object string
, int log
)
9778 CHECK_STRING (string
);
9784 if (noninteractive_need_newline
)
9785 putc ('\n', stderr
);
9786 noninteractive_need_newline
= 0;
9787 fprintf (stderr
, m
, SDATA (string
));
9788 if (!cursor_in_echo_area
)
9789 fprintf (stderr
, "\n");
9793 else if (INTERACTIVE
)
9795 /* The frame whose minibuffer we're going to display the message on.
9796 It may be larger than the selected frame, so we need
9797 to use its buffer, not the selected frame's buffer. */
9798 Lisp_Object mini_window
;
9799 struct frame
*f
, *sf
= SELECTED_FRAME ();
9801 /* Get the frame containing the minibuffer
9802 that the selected frame is using. */
9803 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9804 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9806 /* A null message buffer means that the frame hasn't really been
9807 initialized yet. Error messages get reported properly by
9808 cmd_error, so this must be just an informative message; toss it. */
9809 if (FRAME_MESSAGE_BUF (f
))
9811 Lisp_Object args
[2], msg
;
9812 struct gcpro gcpro1
, gcpro2
;
9814 args
[0] = build_string (m
);
9815 args
[1] = msg
= string
;
9816 GCPRO2 (args
[0], msg
);
9819 msg
= Fformat (2, args
);
9822 message3 (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9824 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9828 /* Print should start at the beginning of the message
9829 buffer next time. */
9830 message_buf_print
= 0;
9836 /* Dump an informative message to the minibuf. If M is 0, clear out
9837 any existing message, and let the mini-buffer text show through. */
9840 vmessage (const char *m
, va_list ap
)
9846 if (noninteractive_need_newline
)
9847 putc ('\n', stderr
);
9848 noninteractive_need_newline
= 0;
9849 vfprintf (stderr
, m
, ap
);
9850 if (cursor_in_echo_area
== 0)
9851 fprintf (stderr
, "\n");
9855 else if (INTERACTIVE
)
9857 /* The frame whose mini-buffer we're going to display the message
9858 on. It may be larger than the selected frame, so we need to
9859 use its buffer, not the selected frame's buffer. */
9860 Lisp_Object mini_window
;
9861 struct frame
*f
, *sf
= SELECTED_FRAME ();
9863 /* Get the frame containing the mini-buffer
9864 that the selected frame is using. */
9865 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9866 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9868 /* A null message buffer means that the frame hasn't really been
9869 initialized yet. Error messages get reported properly by
9870 cmd_error, so this must be just an informative message; toss
9872 if (FRAME_MESSAGE_BUF (f
))
9878 len
= doprnt (FRAME_MESSAGE_BUF (f
),
9879 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, ap
);
9881 message2 (FRAME_MESSAGE_BUF (f
), len
, 1);
9886 /* Print should start at the beginning of the message
9887 buffer next time. */
9888 message_buf_print
= 0;
9894 message (const char *m
, ...)
9904 /* The non-logging version of message. */
9907 message_nolog (const char *m
, ...)
9909 Lisp_Object old_log_max
;
9912 old_log_max
= Vmessage_log_max
;
9913 Vmessage_log_max
= Qnil
;
9915 Vmessage_log_max
= old_log_max
;
9921 /* Display the current message in the current mini-buffer. This is
9922 only called from error handlers in process.c, and is not time
9926 update_echo_area (void)
9928 if (!NILP (echo_area_buffer
[0]))
9931 string
= Fcurrent_message ();
9932 message3 (string
, SBYTES (string
),
9933 !NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
9938 /* Make sure echo area buffers in `echo_buffers' are live.
9939 If they aren't, make new ones. */
9942 ensure_echo_area_buffers (void)
9946 for (i
= 0; i
< 2; ++i
)
9947 if (!BUFFERP (echo_buffer
[i
])
9948 || !BUFFER_LIVE_P (XBUFFER (echo_buffer
[i
])))
9951 Lisp_Object old_buffer
;
9954 old_buffer
= echo_buffer
[i
];
9955 echo_buffer
[i
] = Fget_buffer_create
9956 (make_formatted_string (name
, " *Echo Area %d*", i
));
9957 bset_truncate_lines (XBUFFER (echo_buffer
[i
]), Qnil
);
9958 /* to force word wrap in echo area -
9959 it was decided to postpone this*/
9960 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
9962 for (j
= 0; j
< 2; ++j
)
9963 if (EQ (old_buffer
, echo_area_buffer
[j
]))
9964 echo_area_buffer
[j
] = echo_buffer
[i
];
9969 /* Call FN with args A1..A4 with either the current or last displayed
9970 echo_area_buffer as current buffer.
9972 WHICH zero means use the current message buffer
9973 echo_area_buffer[0]. If that is nil, choose a suitable buffer
9974 from echo_buffer[] and clear it.
9976 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
9977 suitable buffer from echo_buffer[] and clear it.
9979 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
9980 that the current message becomes the last displayed one, make
9981 choose a suitable buffer for echo_area_buffer[0], and clear it.
9983 Value is what FN returns. */
9986 with_echo_area_buffer (struct window
*w
, int which
,
9987 int (*fn
) (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t),
9988 ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
9991 int this_one
, the_other
, clear_buffer_p
, rc
;
9992 ptrdiff_t count
= SPECPDL_INDEX ();
9994 /* If buffers aren't live, make new ones. */
9995 ensure_echo_area_buffers ();
10000 this_one
= 0, the_other
= 1;
10001 else if (which
> 0)
10002 this_one
= 1, the_other
= 0;
10005 this_one
= 0, the_other
= 1;
10006 clear_buffer_p
= 1;
10008 /* We need a fresh one in case the current echo buffer equals
10009 the one containing the last displayed echo area message. */
10010 if (!NILP (echo_area_buffer
[this_one
])
10011 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
10012 echo_area_buffer
[this_one
] = Qnil
;
10015 /* Choose a suitable buffer from echo_buffer[] is we don't
10017 if (NILP (echo_area_buffer
[this_one
]))
10019 echo_area_buffer
[this_one
]
10020 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
10021 ? echo_buffer
[the_other
]
10022 : echo_buffer
[this_one
]);
10023 clear_buffer_p
= 1;
10026 buffer
= echo_area_buffer
[this_one
];
10028 /* Don't get confused by reusing the buffer used for echoing
10029 for a different purpose. */
10030 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
10033 record_unwind_protect (unwind_with_echo_area_buffer
,
10034 with_echo_area_buffer_unwind_data (w
));
10036 /* Make the echo area buffer current. Note that for display
10037 purposes, it is not necessary that the displayed window's buffer
10038 == current_buffer, except for text property lookup. So, let's
10039 only set that buffer temporarily here without doing a full
10040 Fset_window_buffer. We must also change w->pointm, though,
10041 because otherwise an assertions in unshow_buffer fails, and Emacs
10043 set_buffer_internal_1 (XBUFFER (buffer
));
10046 wset_buffer (w
, buffer
);
10047 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
10050 bset_undo_list (current_buffer
, Qt
);
10051 bset_read_only (current_buffer
, Qnil
);
10052 specbind (Qinhibit_read_only
, Qt
);
10053 specbind (Qinhibit_modification_hooks
, Qt
);
10055 if (clear_buffer_p
&& Z
> BEG
)
10056 del_range (BEG
, Z
);
10058 eassert (BEGV
>= BEG
);
10059 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10061 rc
= fn (a1
, a2
, a3
, a4
);
10063 eassert (BEGV
>= BEG
);
10064 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10066 unbind_to (count
, Qnil
);
10071 /* Save state that should be preserved around the call to the function
10072 FN called in with_echo_area_buffer. */
10075 with_echo_area_buffer_unwind_data (struct window
*w
)
10078 Lisp_Object vector
, tmp
;
10080 /* Reduce consing by keeping one vector in
10081 Vwith_echo_area_save_vector. */
10082 vector
= Vwith_echo_area_save_vector
;
10083 Vwith_echo_area_save_vector
= Qnil
;
10086 vector
= Fmake_vector (make_number (7), Qnil
);
10088 XSETBUFFER (tmp
, current_buffer
); ASET (vector
, i
, tmp
); ++i
;
10089 ASET (vector
, i
, Vdeactivate_mark
); ++i
;
10090 ASET (vector
, i
, make_number (windows_or_buffers_changed
)); ++i
;
10094 XSETWINDOW (tmp
, w
); ASET (vector
, i
, tmp
); ++i
;
10095 ASET (vector
, i
, w
->buffer
); ++i
;
10096 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->charpos
)); ++i
;
10097 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->bytepos
)); ++i
;
10102 for (; i
< end
; ++i
)
10103 ASET (vector
, i
, Qnil
);
10106 eassert (i
== ASIZE (vector
));
10111 /* Restore global state from VECTOR which was created by
10112 with_echo_area_buffer_unwind_data. */
10115 unwind_with_echo_area_buffer (Lisp_Object vector
)
10117 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
10118 Vdeactivate_mark
= AREF (vector
, 1);
10119 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
10121 if (WINDOWP (AREF (vector
, 3)))
10124 Lisp_Object buffer
, charpos
, bytepos
;
10126 w
= XWINDOW (AREF (vector
, 3));
10127 buffer
= AREF (vector
, 4);
10128 charpos
= AREF (vector
, 5);
10129 bytepos
= AREF (vector
, 6);
10131 wset_buffer (w
, buffer
);
10132 set_marker_both (w
->pointm
, buffer
,
10133 XFASTINT (charpos
), XFASTINT (bytepos
));
10136 Vwith_echo_area_save_vector
= vector
;
10141 /* Set up the echo area for use by print functions. MULTIBYTE_P
10142 non-zero means we will print multibyte. */
10145 setup_echo_area_for_printing (int multibyte_p
)
10147 /* If we can't find an echo area any more, exit. */
10148 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
10149 Fkill_emacs (Qnil
);
10151 ensure_echo_area_buffers ();
10153 if (!message_buf_print
)
10155 /* A message has been output since the last time we printed.
10156 Choose a fresh echo area buffer. */
10157 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10158 echo_area_buffer
[0] = echo_buffer
[1];
10160 echo_area_buffer
[0] = echo_buffer
[0];
10162 /* Switch to that buffer and clear it. */
10163 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10164 bset_truncate_lines (current_buffer
, Qnil
);
10168 ptrdiff_t count
= SPECPDL_INDEX ();
10169 specbind (Qinhibit_read_only
, Qt
);
10170 /* Note that undo recording is always disabled. */
10171 del_range (BEG
, Z
);
10172 unbind_to (count
, Qnil
);
10174 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10176 /* Set up the buffer for the multibyteness we need. */
10178 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10179 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
10181 /* Raise the frame containing the echo area. */
10182 if (minibuffer_auto_raise
)
10184 struct frame
*sf
= SELECTED_FRAME ();
10185 Lisp_Object mini_window
;
10186 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10187 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
10190 message_log_maybe_newline ();
10191 message_buf_print
= 1;
10195 if (NILP (echo_area_buffer
[0]))
10197 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10198 echo_area_buffer
[0] = echo_buffer
[1];
10200 echo_area_buffer
[0] = echo_buffer
[0];
10203 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
10205 /* Someone switched buffers between print requests. */
10206 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10207 bset_truncate_lines (current_buffer
, Qnil
);
10213 /* Display an echo area message in window W. Value is non-zero if W's
10214 height is changed. If display_last_displayed_message_p is
10215 non-zero, display the message that was last displayed, otherwise
10216 display the current message. */
10219 display_echo_area (struct window
*w
)
10221 int i
, no_message_p
, window_height_changed_p
;
10223 /* Temporarily disable garbage collections while displaying the echo
10224 area. This is done because a GC can print a message itself.
10225 That message would modify the echo area buffer's contents while a
10226 redisplay of the buffer is going on, and seriously confuse
10228 ptrdiff_t count
= inhibit_garbage_collection ();
10230 /* If there is no message, we must call display_echo_area_1
10231 nevertheless because it resizes the window. But we will have to
10232 reset the echo_area_buffer in question to nil at the end because
10233 with_echo_area_buffer will sets it to an empty buffer. */
10234 i
= display_last_displayed_message_p
? 1 : 0;
10235 no_message_p
= NILP (echo_area_buffer
[i
]);
10237 window_height_changed_p
10238 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
10239 display_echo_area_1
,
10240 (intptr_t) w
, Qnil
, 0, 0);
10243 echo_area_buffer
[i
] = Qnil
;
10245 unbind_to (count
, Qnil
);
10246 return window_height_changed_p
;
10250 /* Helper for display_echo_area. Display the current buffer which
10251 contains the current echo area message in window W, a mini-window,
10252 a pointer to which is passed in A1. A2..A4 are currently not used.
10253 Change the height of W so that all of the message is displayed.
10254 Value is non-zero if height of W was changed. */
10257 display_echo_area_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10260 struct window
*w
= (struct window
*) i1
;
10261 Lisp_Object window
;
10262 struct text_pos start
;
10263 int window_height_changed_p
= 0;
10265 /* Do this before displaying, so that we have a large enough glyph
10266 matrix for the display. If we can't get enough space for the
10267 whole text, display the last N lines. That works by setting w->start. */
10268 window_height_changed_p
= resize_mini_window (w
, 0);
10270 /* Use the starting position chosen by resize_mini_window. */
10271 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
10274 clear_glyph_matrix (w
->desired_matrix
);
10275 XSETWINDOW (window
, w
);
10276 try_window (window
, start
, 0);
10278 return window_height_changed_p
;
10282 /* Resize the echo area window to exactly the size needed for the
10283 currently displayed message, if there is one. If a mini-buffer
10284 is active, don't shrink it. */
10287 resize_echo_area_exactly (void)
10289 if (BUFFERP (echo_area_buffer
[0])
10290 && WINDOWP (echo_area_window
))
10292 struct window
*w
= XWINDOW (echo_area_window
);
10294 Lisp_Object resize_exactly
;
10296 if (minibuf_level
== 0)
10297 resize_exactly
= Qt
;
10299 resize_exactly
= Qnil
;
10301 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
10302 (intptr_t) w
, resize_exactly
,
10306 ++windows_or_buffers_changed
;
10307 ++update_mode_lines
;
10308 redisplay_internal ();
10314 /* Callback function for with_echo_area_buffer, when used from
10315 resize_echo_area_exactly. A1 contains a pointer to the window to
10316 resize, EXACTLY non-nil means resize the mini-window exactly to the
10317 size of the text displayed. A3 and A4 are not used. Value is what
10318 resize_mini_window returns. */
10321 resize_mini_window_1 (ptrdiff_t a1
, Lisp_Object exactly
, ptrdiff_t a3
, ptrdiff_t a4
)
10324 return resize_mini_window ((struct window
*) i1
, !NILP (exactly
));
10328 /* Resize mini-window W to fit the size of its contents. EXACT_P
10329 means size the window exactly to the size needed. Otherwise, it's
10330 only enlarged until W's buffer is empty.
10332 Set W->start to the right place to begin display. If the whole
10333 contents fit, start at the beginning. Otherwise, start so as
10334 to make the end of the contents appear. This is particularly
10335 important for y-or-n-p, but seems desirable generally.
10337 Value is non-zero if the window height has been changed. */
10340 resize_mini_window (struct window
*w
, int exact_p
)
10342 struct frame
*f
= XFRAME (w
->frame
);
10343 int window_height_changed_p
= 0;
10345 eassert (MINI_WINDOW_P (w
));
10347 /* By default, start display at the beginning. */
10348 set_marker_both (w
->start
, w
->buffer
,
10349 BUF_BEGV (XBUFFER (w
->buffer
)),
10350 BUF_BEGV_BYTE (XBUFFER (w
->buffer
)));
10352 /* Don't resize windows while redisplaying a window; it would
10353 confuse redisplay functions when the size of the window they are
10354 displaying changes from under them. Such a resizing can happen,
10355 for instance, when which-func prints a long message while
10356 we are running fontification-functions. We're running these
10357 functions with safe_call which binds inhibit-redisplay to t. */
10358 if (!NILP (Vinhibit_redisplay
))
10361 /* Nil means don't try to resize. */
10362 if (NILP (Vresize_mini_windows
)
10363 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
10366 if (!FRAME_MINIBUF_ONLY_P (f
))
10369 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10370 int total_height
= WINDOW_TOTAL_LINES (root
) + WINDOW_TOTAL_LINES (w
);
10372 EMACS_INT max_height
;
10373 int unit
= FRAME_LINE_HEIGHT (f
);
10374 struct text_pos start
;
10375 struct buffer
*old_current_buffer
= NULL
;
10377 if (current_buffer
!= XBUFFER (w
->buffer
))
10379 old_current_buffer
= current_buffer
;
10380 set_buffer_internal (XBUFFER (w
->buffer
));
10383 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10385 /* Compute the max. number of lines specified by the user. */
10386 if (FLOATP (Vmax_mini_window_height
))
10387 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_LINES (f
);
10388 else if (INTEGERP (Vmax_mini_window_height
))
10389 max_height
= XINT (Vmax_mini_window_height
);
10391 max_height
= total_height
/ 4;
10393 /* Correct that max. height if it's bogus. */
10394 max_height
= max (1, max_height
);
10395 max_height
= min (total_height
, max_height
);
10397 /* Find out the height of the text in the window. */
10398 if (it
.line_wrap
== TRUNCATE
)
10403 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
10404 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
10405 height
= it
.current_y
+ last_height
;
10407 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
10408 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
10409 height
= (height
+ unit
- 1) / unit
;
10412 /* Compute a suitable window start. */
10413 if (height
> max_height
)
10415 height
= max_height
;
10416 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10417 move_it_vertically_backward (&it
, (height
- 1) * unit
);
10418 start
= it
.current
.pos
;
10421 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
10422 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
10424 if (EQ (Vresize_mini_windows
, Qgrow_only
))
10426 /* Let it grow only, until we display an empty message, in which
10427 case the window shrinks again. */
10428 if (height
> WINDOW_TOTAL_LINES (w
))
10430 int old_height
= WINDOW_TOTAL_LINES (w
);
10431 freeze_window_starts (f
, 1);
10432 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10433 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10435 else if (height
< WINDOW_TOTAL_LINES (w
)
10436 && (exact_p
|| BEGV
== ZV
))
10438 int old_height
= WINDOW_TOTAL_LINES (w
);
10439 freeze_window_starts (f
, 0);
10440 shrink_mini_window (w
);
10441 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10446 /* Always resize to exact size needed. */
10447 if (height
> WINDOW_TOTAL_LINES (w
))
10449 int old_height
= WINDOW_TOTAL_LINES (w
);
10450 freeze_window_starts (f
, 1);
10451 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10452 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10454 else if (height
< WINDOW_TOTAL_LINES (w
))
10456 int old_height
= WINDOW_TOTAL_LINES (w
);
10457 freeze_window_starts (f
, 0);
10458 shrink_mini_window (w
);
10462 freeze_window_starts (f
, 1);
10463 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10466 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10470 if (old_current_buffer
)
10471 set_buffer_internal (old_current_buffer
);
10474 return window_height_changed_p
;
10478 /* Value is the current message, a string, or nil if there is no
10479 current message. */
10482 current_message (void)
10486 if (!BUFFERP (echo_area_buffer
[0]))
10490 with_echo_area_buffer (0, 0, current_message_1
,
10491 (intptr_t) &msg
, Qnil
, 0, 0);
10493 echo_area_buffer
[0] = Qnil
;
10501 current_message_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10504 Lisp_Object
*msg
= (Lisp_Object
*) i1
;
10507 *msg
= make_buffer_string (BEG
, Z
, 1);
10514 /* Push the current message on Vmessage_stack for later restoration
10515 by restore_message. Value is non-zero if the current message isn't
10516 empty. This is a relatively infrequent operation, so it's not
10517 worth optimizing. */
10520 push_message (void)
10522 Lisp_Object msg
= current_message ();
10523 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
10524 return STRINGP (msg
);
10528 /* Restore message display from the top of Vmessage_stack. */
10531 restore_message (void)
10535 eassert (CONSP (Vmessage_stack
));
10536 msg
= XCAR (Vmessage_stack
);
10538 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
10540 message3_nolog (msg
, 0, 0);
10544 /* Handler for record_unwind_protect calling pop_message. */
10547 pop_message_unwind (Lisp_Object dummy
)
10553 /* Pop the top-most entry off Vmessage_stack. */
10558 eassert (CONSP (Vmessage_stack
));
10559 Vmessage_stack
= XCDR (Vmessage_stack
);
10563 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
10564 exits. If the stack is not empty, we have a missing pop_message
10568 check_message_stack (void)
10570 if (!NILP (Vmessage_stack
))
10575 /* Truncate to NCHARS what will be displayed in the echo area the next
10576 time we display it---but don't redisplay it now. */
10579 truncate_echo_area (ptrdiff_t nchars
)
10582 echo_area_buffer
[0] = Qnil
;
10583 /* A null message buffer means that the frame hasn't really been
10584 initialized yet. Error messages get reported properly by
10585 cmd_error, so this must be just an informative message; toss it. */
10586 else if (!noninteractive
10588 && !NILP (echo_area_buffer
[0]))
10590 struct frame
*sf
= SELECTED_FRAME ();
10591 if (FRAME_MESSAGE_BUF (sf
))
10592 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
10597 /* Helper function for truncate_echo_area. Truncate the current
10598 message to at most NCHARS characters. */
10601 truncate_message_1 (ptrdiff_t nchars
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10603 if (BEG
+ nchars
< Z
)
10604 del_range (BEG
+ nchars
, Z
);
10606 echo_area_buffer
[0] = Qnil
;
10610 /* Set the current message to a substring of S or STRING.
10612 If STRING is a Lisp string, set the message to the first NBYTES
10613 bytes from STRING. NBYTES zero means use the whole string. If
10614 STRING is multibyte, the message will be displayed multibyte.
10616 If S is not null, set the message to the first LEN bytes of S. LEN
10617 zero means use the whole string. MULTIBYTE_P non-zero means S is
10618 multibyte. Display the message multibyte in that case.
10620 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
10621 to t before calling set_message_1 (which calls insert).
10625 set_message (const char *s
, Lisp_Object string
,
10626 ptrdiff_t nbytes
, int multibyte_p
)
10628 message_enable_multibyte
10629 = ((s
&& multibyte_p
)
10630 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
10632 with_echo_area_buffer (0, -1, set_message_1
,
10633 (intptr_t) s
, string
, nbytes
, multibyte_p
);
10634 message_buf_print
= 0;
10635 help_echo_showing_p
= 0;
10637 if (STRINGP (Vdebug_on_message
)
10638 && fast_string_match (Vdebug_on_message
, string
) >= 0)
10639 call_debugger (list2 (Qerror
, string
));
10643 /* Helper function for set_message. Arguments have the same meaning
10644 as there, with A1 corresponding to S and A2 corresponding to STRING
10645 This function is called with the echo area buffer being
10649 set_message_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t nbytes
, ptrdiff_t multibyte_p
)
10652 const char *s
= (const char *) i1
;
10653 const unsigned char *msg
= (const unsigned char *) s
;
10654 Lisp_Object string
= a2
;
10656 /* Change multibyteness of the echo buffer appropriately. */
10657 if (message_enable_multibyte
10658 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10659 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
10661 bset_truncate_lines (current_buffer
, message_truncate_lines
? Qt
: Qnil
);
10662 if (!NILP (BVAR (current_buffer
, bidi_display_reordering
)))
10663 bset_bidi_paragraph_direction (current_buffer
, Qleft_to_right
);
10665 /* Insert new message at BEG. */
10666 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10668 if (STRINGP (string
))
10673 nbytes
= SBYTES (string
);
10674 nchars
= string_byte_to_char (string
, nbytes
);
10676 /* This function takes care of single/multibyte conversion. We
10677 just have to ensure that the echo area buffer has the right
10678 setting of enable_multibyte_characters. */
10679 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
10684 nbytes
= strlen (s
);
10686 if (multibyte_p
&& NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10688 /* Convert from multi-byte to single-byte. */
10693 /* Convert a multibyte string to single-byte. */
10694 for (i
= 0; i
< nbytes
; i
+= n
)
10696 c
= string_char_and_length (msg
+ i
, &n
);
10697 work
[0] = (ASCII_CHAR_P (c
)
10699 : multibyte_char_to_unibyte (c
));
10700 insert_1_both (work
, 1, 1, 1, 0, 0);
10703 else if (!multibyte_p
10704 && !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10706 /* Convert from single-byte to multi-byte. */
10709 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
10711 /* Convert a single-byte string to multibyte. */
10712 for (i
= 0; i
< nbytes
; i
++)
10715 MAKE_CHAR_MULTIBYTE (c
);
10716 n
= CHAR_STRING (c
, str
);
10717 insert_1_both ((char *) str
, 1, n
, 1, 0, 0);
10721 insert_1 (s
, nbytes
, 1, 0, 0);
10728 /* Clear messages. CURRENT_P non-zero means clear the current
10729 message. LAST_DISPLAYED_P non-zero means clear the message
10733 clear_message (int current_p
, int last_displayed_p
)
10737 echo_area_buffer
[0] = Qnil
;
10738 message_cleared_p
= 1;
10741 if (last_displayed_p
)
10742 echo_area_buffer
[1] = Qnil
;
10744 message_buf_print
= 0;
10747 /* Clear garbaged frames.
10749 This function is used where the old redisplay called
10750 redraw_garbaged_frames which in turn called redraw_frame which in
10751 turn called clear_frame. The call to clear_frame was a source of
10752 flickering. I believe a clear_frame is not necessary. It should
10753 suffice in the new redisplay to invalidate all current matrices,
10754 and ensure a complete redisplay of all windows. */
10757 clear_garbaged_frames (void)
10759 if (frame_garbaged
)
10761 Lisp_Object tail
, frame
;
10762 int changed_count
= 0;
10764 FOR_EACH_FRAME (tail
, frame
)
10766 struct frame
*f
= XFRAME (frame
);
10768 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
10773 f
->force_flush_display_p
= 1;
10775 clear_current_matrices (f
);
10782 frame_garbaged
= 0;
10784 ++windows_or_buffers_changed
;
10789 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
10790 is non-zero update selected_frame. Value is non-zero if the
10791 mini-windows height has been changed. */
10794 echo_area_display (int update_frame_p
)
10796 Lisp_Object mini_window
;
10799 int window_height_changed_p
= 0;
10800 struct frame
*sf
= SELECTED_FRAME ();
10802 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10803 w
= XWINDOW (mini_window
);
10804 f
= XFRAME (WINDOW_FRAME (w
));
10806 /* Don't display if frame is invisible or not yet initialized. */
10807 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
10810 #ifdef HAVE_WINDOW_SYSTEM
10811 /* When Emacs starts, selected_frame may be the initial terminal
10812 frame. If we let this through, a message would be displayed on
10814 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
10816 #endif /* HAVE_WINDOW_SYSTEM */
10818 /* Redraw garbaged frames. */
10819 clear_garbaged_frames ();
10821 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
10823 echo_area_window
= mini_window
;
10824 window_height_changed_p
= display_echo_area (w
);
10825 w
->must_be_updated_p
= 1;
10827 /* Update the display, unless called from redisplay_internal.
10828 Also don't update the screen during redisplay itself. The
10829 update will happen at the end of redisplay, and an update
10830 here could cause confusion. */
10831 if (update_frame_p
&& !redisplaying_p
)
10835 /* If the display update has been interrupted by pending
10836 input, update mode lines in the frame. Due to the
10837 pending input, it might have been that redisplay hasn't
10838 been called, so that mode lines above the echo area are
10839 garbaged. This looks odd, so we prevent it here. */
10840 if (!display_completed
)
10841 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
10843 if (window_height_changed_p
10844 /* Don't do this if Emacs is shutting down. Redisplay
10845 needs to run hooks. */
10846 && !NILP (Vrun_hooks
))
10848 /* Must update other windows. Likewise as in other
10849 cases, don't let this update be interrupted by
10851 ptrdiff_t count
= SPECPDL_INDEX ();
10852 specbind (Qredisplay_dont_pause
, Qt
);
10853 windows_or_buffers_changed
= 1;
10854 redisplay_internal ();
10855 unbind_to (count
, Qnil
);
10857 else if (FRAME_WINDOW_P (f
) && n
== 0)
10859 /* Window configuration is the same as before.
10860 Can do with a display update of the echo area,
10861 unless we displayed some mode lines. */
10862 update_single_window (w
, 1);
10863 FRAME_RIF (f
)->flush_display (f
);
10866 update_frame (f
, 1, 1);
10868 /* If cursor is in the echo area, make sure that the next
10869 redisplay displays the minibuffer, so that the cursor will
10870 be replaced with what the minibuffer wants. */
10871 if (cursor_in_echo_area
)
10872 ++windows_or_buffers_changed
;
10875 else if (!EQ (mini_window
, selected_window
))
10876 windows_or_buffers_changed
++;
10878 /* Last displayed message is now the current message. */
10879 echo_area_buffer
[1] = echo_area_buffer
[0];
10880 /* Inform read_char that we're not echoing. */
10881 echo_message_buffer
= Qnil
;
10883 /* Prevent redisplay optimization in redisplay_internal by resetting
10884 this_line_start_pos. This is done because the mini-buffer now
10885 displays the message instead of its buffer text. */
10886 if (EQ (mini_window
, selected_window
))
10887 CHARPOS (this_line_start_pos
) = 0;
10889 return window_height_changed_p
;
10894 /***********************************************************************
10895 Mode Lines and Frame Titles
10896 ***********************************************************************/
10898 /* A buffer for constructing non-propertized mode-line strings and
10899 frame titles in it; allocated from the heap in init_xdisp and
10900 resized as needed in store_mode_line_noprop_char. */
10902 static char *mode_line_noprop_buf
;
10904 /* The buffer's end, and a current output position in it. */
10906 static char *mode_line_noprop_buf_end
;
10907 static char *mode_line_noprop_ptr
;
10909 #define MODE_LINE_NOPROP_LEN(start) \
10910 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
10913 MODE_LINE_DISPLAY
= 0,
10917 } mode_line_target
;
10919 /* Alist that caches the results of :propertize.
10920 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
10921 static Lisp_Object mode_line_proptrans_alist
;
10923 /* List of strings making up the mode-line. */
10924 static Lisp_Object mode_line_string_list
;
10926 /* Base face property when building propertized mode line string. */
10927 static Lisp_Object mode_line_string_face
;
10928 static Lisp_Object mode_line_string_face_prop
;
10931 /* Unwind data for mode line strings */
10933 static Lisp_Object Vmode_line_unwind_vector
;
10936 format_mode_line_unwind_data (struct frame
*target_frame
,
10937 struct buffer
*obuf
,
10939 int save_proptrans
)
10941 Lisp_Object vector
, tmp
;
10943 /* Reduce consing by keeping one vector in
10944 Vwith_echo_area_save_vector. */
10945 vector
= Vmode_line_unwind_vector
;
10946 Vmode_line_unwind_vector
= Qnil
;
10949 vector
= Fmake_vector (make_number (10), Qnil
);
10951 ASET (vector
, 0, make_number (mode_line_target
));
10952 ASET (vector
, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
10953 ASET (vector
, 2, mode_line_string_list
);
10954 ASET (vector
, 3, save_proptrans
? mode_line_proptrans_alist
: Qt
);
10955 ASET (vector
, 4, mode_line_string_face
);
10956 ASET (vector
, 5, mode_line_string_face_prop
);
10959 XSETBUFFER (tmp
, obuf
);
10962 ASET (vector
, 6, tmp
);
10963 ASET (vector
, 7, owin
);
10966 /* Similarly to `with-selected-window', if the operation selects
10967 a window on another frame, we must restore that frame's
10968 selected window, and (for a tty) the top-frame. */
10969 ASET (vector
, 8, target_frame
->selected_window
);
10970 if (FRAME_TERMCAP_P (target_frame
))
10971 ASET (vector
, 9, FRAME_TTY (target_frame
)->top_frame
);
10978 unwind_format_mode_line (Lisp_Object vector
)
10980 Lisp_Object old_window
= AREF (vector
, 7);
10981 Lisp_Object target_frame_window
= AREF (vector
, 8);
10982 Lisp_Object old_top_frame
= AREF (vector
, 9);
10984 mode_line_target
= XINT (AREF (vector
, 0));
10985 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
10986 mode_line_string_list
= AREF (vector
, 2);
10987 if (! EQ (AREF (vector
, 3), Qt
))
10988 mode_line_proptrans_alist
= AREF (vector
, 3);
10989 mode_line_string_face
= AREF (vector
, 4);
10990 mode_line_string_face_prop
= AREF (vector
, 5);
10992 /* Select window before buffer, since it may change the buffer. */
10993 if (!NILP (old_window
))
10995 /* If the operation that we are unwinding had selected a window
10996 on a different frame, reset its frame-selected-window. For a
10997 text terminal, reset its top-frame if necessary. */
10998 if (!NILP (target_frame_window
))
11001 = WINDOW_FRAME (XWINDOW (target_frame_window
));
11003 if (!EQ (frame
, WINDOW_FRAME (XWINDOW (old_window
))))
11004 Fselect_window (target_frame_window
, Qt
);
11006 if (!NILP (old_top_frame
) && !EQ (old_top_frame
, frame
))
11007 Fselect_frame (old_top_frame
, Qt
);
11010 Fselect_window (old_window
, Qt
);
11013 if (!NILP (AREF (vector
, 6)))
11015 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
11016 ASET (vector
, 6, Qnil
);
11019 Vmode_line_unwind_vector
= vector
;
11024 /* Store a single character C for the frame title in mode_line_noprop_buf.
11025 Re-allocate mode_line_noprop_buf if necessary. */
11028 store_mode_line_noprop_char (char c
)
11030 /* If output position has reached the end of the allocated buffer,
11031 increase the buffer's size. */
11032 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
11034 ptrdiff_t len
= MODE_LINE_NOPROP_LEN (0);
11035 ptrdiff_t size
= len
;
11036 mode_line_noprop_buf
=
11037 xpalloc (mode_line_noprop_buf
, &size
, 1, STRING_BYTES_BOUND
, 1);
11038 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
11039 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
11042 *mode_line_noprop_ptr
++ = c
;
11046 /* Store part of a frame title in mode_line_noprop_buf, beginning at
11047 mode_line_noprop_ptr. STRING is the string to store. Do not copy
11048 characters that yield more columns than PRECISION; PRECISION <= 0
11049 means copy the whole string. Pad with spaces until FIELD_WIDTH
11050 number of characters have been copied; FIELD_WIDTH <= 0 means don't
11051 pad. Called from display_mode_element when it is used to build a
11055 store_mode_line_noprop (const char *string
, int field_width
, int precision
)
11057 const unsigned char *str
= (const unsigned char *) string
;
11059 ptrdiff_t dummy
, nbytes
;
11061 /* Copy at most PRECISION chars from STR. */
11062 nbytes
= strlen (string
);
11063 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
11065 store_mode_line_noprop_char (*str
++);
11067 /* Fill up with spaces until FIELD_WIDTH reached. */
11068 while (field_width
> 0
11069 && n
< field_width
)
11071 store_mode_line_noprop_char (' ');
11078 /***********************************************************************
11080 ***********************************************************************/
11082 #ifdef HAVE_WINDOW_SYSTEM
11084 /* Set the title of FRAME, if it has changed. The title format is
11085 Vicon_title_format if FRAME is iconified, otherwise it is
11086 frame_title_format. */
11089 x_consider_frame_title (Lisp_Object frame
)
11091 struct frame
*f
= XFRAME (frame
);
11093 if (FRAME_WINDOW_P (f
)
11094 || FRAME_MINIBUF_ONLY_P (f
)
11095 || f
->explicit_name
)
11097 /* Do we have more than one visible frame on this X display? */
11098 Lisp_Object tail
, other_frame
, fmt
;
11099 ptrdiff_t title_start
;
11103 ptrdiff_t count
= SPECPDL_INDEX ();
11105 FOR_EACH_FRAME (tail
, other_frame
)
11107 struct frame
*tf
= XFRAME (other_frame
);
11110 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
11111 && !FRAME_MINIBUF_ONLY_P (tf
)
11112 && !EQ (other_frame
, tip_frame
)
11113 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
11117 /* Set global variable indicating that multiple frames exist. */
11118 multiple_frames
= CONSP (tail
);
11120 /* Switch to the buffer of selected window of the frame. Set up
11121 mode_line_target so that display_mode_element will output into
11122 mode_line_noprop_buf; then display the title. */
11123 record_unwind_protect (unwind_format_mode_line
,
11124 format_mode_line_unwind_data
11125 (f
, current_buffer
, selected_window
, 0));
11127 Fselect_window (f
->selected_window
, Qt
);
11128 set_buffer_internal_1
11129 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
11130 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
11132 mode_line_target
= MODE_LINE_TITLE
;
11133 title_start
= MODE_LINE_NOPROP_LEN (0);
11134 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
11135 NULL
, DEFAULT_FACE_ID
);
11136 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
11137 len
= MODE_LINE_NOPROP_LEN (title_start
);
11138 title
= mode_line_noprop_buf
+ title_start
;
11139 unbind_to (count
, Qnil
);
11141 /* Set the title only if it's changed. This avoids consing in
11142 the common case where it hasn't. (If it turns out that we've
11143 already wasted too much time by walking through the list with
11144 display_mode_element, then we might need to optimize at a
11145 higher level than this.) */
11146 if (! STRINGP (f
->name
)
11147 || SBYTES (f
->name
) != len
11148 || memcmp (title
, SDATA (f
->name
), len
) != 0)
11149 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
11153 #endif /* not HAVE_WINDOW_SYSTEM */
11156 /***********************************************************************
11158 ***********************************************************************/
11161 /* Prepare for redisplay by updating menu-bar item lists when
11162 appropriate. This can call eval. */
11165 prepare_menu_bars (void)
11168 struct gcpro gcpro1
, gcpro2
;
11170 Lisp_Object tooltip_frame
;
11172 #ifdef HAVE_WINDOW_SYSTEM
11173 tooltip_frame
= tip_frame
;
11175 tooltip_frame
= Qnil
;
11178 /* Update all frame titles based on their buffer names, etc. We do
11179 this before the menu bars so that the buffer-menu will show the
11180 up-to-date frame titles. */
11181 #ifdef HAVE_WINDOW_SYSTEM
11182 if (windows_or_buffers_changed
|| update_mode_lines
)
11184 Lisp_Object tail
, frame
;
11186 FOR_EACH_FRAME (tail
, frame
)
11188 f
= XFRAME (frame
);
11189 if (!EQ (frame
, tooltip_frame
)
11190 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
11191 x_consider_frame_title (frame
);
11194 #endif /* HAVE_WINDOW_SYSTEM */
11196 /* Update the menu bar item lists, if appropriate. This has to be
11197 done before any actual redisplay or generation of display lines. */
11198 all_windows
= (update_mode_lines
11199 || buffer_shared
> 1
11200 || windows_or_buffers_changed
);
11203 Lisp_Object tail
, frame
;
11204 ptrdiff_t count
= SPECPDL_INDEX ();
11205 /* 1 means that update_menu_bar has run its hooks
11206 so any further calls to update_menu_bar shouldn't do so again. */
11207 int menu_bar_hooks_run
= 0;
11209 record_unwind_save_match_data ();
11211 FOR_EACH_FRAME (tail
, frame
)
11213 f
= XFRAME (frame
);
11215 /* Ignore tooltip frame. */
11216 if (EQ (frame
, tooltip_frame
))
11219 /* If a window on this frame changed size, report that to
11220 the user and clear the size-change flag. */
11221 if (FRAME_WINDOW_SIZES_CHANGED (f
))
11223 Lisp_Object functions
;
11225 /* Clear flag first in case we get an error below. */
11226 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
11227 functions
= Vwindow_size_change_functions
;
11228 GCPRO2 (tail
, functions
);
11230 while (CONSP (functions
))
11232 if (!EQ (XCAR (functions
), Qt
))
11233 call1 (XCAR (functions
), frame
);
11234 functions
= XCDR (functions
);
11240 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
11241 #ifdef HAVE_WINDOW_SYSTEM
11242 update_tool_bar (f
, 0);
11245 if (windows_or_buffers_changed
11248 (f
, Fbuffer_modified_p (XWINDOW (f
->selected_window
)->buffer
));
11253 unbind_to (count
, Qnil
);
11257 struct frame
*sf
= SELECTED_FRAME ();
11258 update_menu_bar (sf
, 1, 0);
11259 #ifdef HAVE_WINDOW_SYSTEM
11260 update_tool_bar (sf
, 1);
11266 /* Update the menu bar item list for frame F. This has to be done
11267 before we start to fill in any display lines, because it can call
11270 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
11272 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
11273 already ran the menu bar hooks for this redisplay, so there
11274 is no need to run them again. The return value is the
11275 updated value of this flag, to pass to the next call. */
11278 update_menu_bar (struct frame
*f
, int save_match_data
, int hooks_run
)
11280 Lisp_Object window
;
11281 register struct window
*w
;
11283 /* If called recursively during a menu update, do nothing. This can
11284 happen when, for instance, an activate-menubar-hook causes a
11286 if (inhibit_menubar_update
)
11289 window
= FRAME_SELECTED_WINDOW (f
);
11290 w
= XWINDOW (window
);
11292 if (FRAME_WINDOW_P (f
)
11294 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11295 || defined (HAVE_NS) || defined (USE_GTK)
11296 FRAME_EXTERNAL_MENU_BAR (f
)
11298 FRAME_MENU_BAR_LINES (f
) > 0
11300 : FRAME_MENU_BAR_LINES (f
) > 0)
11302 /* If the user has switched buffers or windows, we need to
11303 recompute to reflect the new bindings. But we'll
11304 recompute when update_mode_lines is set too; that means
11305 that people can use force-mode-line-update to request
11306 that the menu bar be recomputed. The adverse effect on
11307 the rest of the redisplay algorithm is about the same as
11308 windows_or_buffers_changed anyway. */
11309 if (windows_or_buffers_changed
11310 /* This used to test w->update_mode_line, but we believe
11311 there is no need to recompute the menu in that case. */
11312 || update_mode_lines
11313 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
11314 < BUF_MODIFF (XBUFFER (w
->buffer
)))
11315 != w
->last_had_star
)
11316 || ((!NILP (Vtransient_mark_mode
)
11317 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
11318 != !NILP (w
->region_showing
)))
11320 struct buffer
*prev
= current_buffer
;
11321 ptrdiff_t count
= SPECPDL_INDEX ();
11323 specbind (Qinhibit_menubar_update
, Qt
);
11325 set_buffer_internal_1 (XBUFFER (w
->buffer
));
11326 if (save_match_data
)
11327 record_unwind_save_match_data ();
11328 if (NILP (Voverriding_local_map_menu_flag
))
11330 specbind (Qoverriding_terminal_local_map
, Qnil
);
11331 specbind (Qoverriding_local_map
, Qnil
);
11336 /* Run the Lucid hook. */
11337 safe_run_hooks (Qactivate_menubar_hook
);
11339 /* If it has changed current-menubar from previous value,
11340 really recompute the menu-bar from the value. */
11341 if (! NILP (Vlucid_menu_bar_dirty_flag
))
11342 call0 (Qrecompute_lucid_menubar
);
11344 safe_run_hooks (Qmenu_bar_update_hook
);
11349 XSETFRAME (Vmenu_updating_frame
, f
);
11350 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
11352 /* Redisplay the menu bar in case we changed it. */
11353 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11354 || defined (HAVE_NS) || defined (USE_GTK)
11355 if (FRAME_WINDOW_P (f
))
11357 #if defined (HAVE_NS)
11358 /* All frames on Mac OS share the same menubar. So only
11359 the selected frame should be allowed to set it. */
11360 if (f
== SELECTED_FRAME ())
11362 set_frame_menubar (f
, 0, 0);
11365 /* On a terminal screen, the menu bar is an ordinary screen
11366 line, and this makes it get updated. */
11367 w
->update_mode_line
= 1;
11368 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11369 /* In the non-toolkit version, the menu bar is an ordinary screen
11370 line, and this makes it get updated. */
11371 w
->update_mode_line
= 1;
11372 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11374 unbind_to (count
, Qnil
);
11375 set_buffer_internal_1 (prev
);
11384 /***********************************************************************
11386 ***********************************************************************/
11388 #ifdef HAVE_WINDOW_SYSTEM
11391 Nominal cursor position -- where to draw output.
11392 HPOS and VPOS are window relative glyph matrix coordinates.
11393 X and Y are window relative pixel coordinates. */
11395 struct cursor_pos output_cursor
;
11399 Set the global variable output_cursor to CURSOR. All cursor
11400 positions are relative to updated_window. */
11403 set_output_cursor (struct cursor_pos
*cursor
)
11405 output_cursor
.hpos
= cursor
->hpos
;
11406 output_cursor
.vpos
= cursor
->vpos
;
11407 output_cursor
.x
= cursor
->x
;
11408 output_cursor
.y
= cursor
->y
;
11413 Set a nominal cursor position.
11415 HPOS and VPOS are column/row positions in a window glyph matrix. X
11416 and Y are window text area relative pixel positions.
11418 If this is done during an update, updated_window will contain the
11419 window that is being updated and the position is the future output
11420 cursor position for that window. If updated_window is null, use
11421 selected_window and display the cursor at the given position. */
11424 x_cursor_to (int vpos
, int hpos
, int y
, int x
)
11428 /* If updated_window is not set, work on selected_window. */
11429 if (updated_window
)
11430 w
= updated_window
;
11432 w
= XWINDOW (selected_window
);
11434 /* Set the output cursor. */
11435 output_cursor
.hpos
= hpos
;
11436 output_cursor
.vpos
= vpos
;
11437 output_cursor
.x
= x
;
11438 output_cursor
.y
= y
;
11440 /* If not called as part of an update, really display the cursor.
11441 This will also set the cursor position of W. */
11442 if (updated_window
== NULL
)
11445 display_and_set_cursor (w
, 1, hpos
, vpos
, x
, y
);
11446 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
11447 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
11452 #endif /* HAVE_WINDOW_SYSTEM */
11455 /***********************************************************************
11457 ***********************************************************************/
11459 #ifdef HAVE_WINDOW_SYSTEM
11461 /* Where the mouse was last time we reported a mouse event. */
11463 FRAME_PTR last_mouse_frame
;
11465 /* Tool-bar item index of the item on which a mouse button was pressed
11468 int last_tool_bar_item
;
11472 update_tool_bar_unwind (Lisp_Object frame
)
11474 selected_frame
= frame
;
11478 /* Update the tool-bar item list for frame F. This has to be done
11479 before we start to fill in any display lines. Called from
11480 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
11481 and restore it here. */
11484 update_tool_bar (struct frame
*f
, int save_match_data
)
11486 #if defined (USE_GTK) || defined (HAVE_NS)
11487 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
11489 int do_update
= WINDOWP (f
->tool_bar_window
)
11490 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0;
11495 Lisp_Object window
;
11498 window
= FRAME_SELECTED_WINDOW (f
);
11499 w
= XWINDOW (window
);
11501 /* If the user has switched buffers or windows, we need to
11502 recompute to reflect the new bindings. But we'll
11503 recompute when update_mode_lines is set too; that means
11504 that people can use force-mode-line-update to request
11505 that the menu bar be recomputed. The adverse effect on
11506 the rest of the redisplay algorithm is about the same as
11507 windows_or_buffers_changed anyway. */
11508 if (windows_or_buffers_changed
11509 || w
->update_mode_line
11510 || update_mode_lines
11511 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
11512 < BUF_MODIFF (XBUFFER (w
->buffer
)))
11513 != w
->last_had_star
)
11514 || ((!NILP (Vtransient_mark_mode
)
11515 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
11516 != !NILP (w
->region_showing
)))
11518 struct buffer
*prev
= current_buffer
;
11519 ptrdiff_t count
= SPECPDL_INDEX ();
11520 Lisp_Object frame
, new_tool_bar
;
11521 int new_n_tool_bar
;
11522 struct gcpro gcpro1
;
11524 /* Set current_buffer to the buffer of the selected
11525 window of the frame, so that we get the right local
11527 set_buffer_internal_1 (XBUFFER (w
->buffer
));
11529 /* Save match data, if we must. */
11530 if (save_match_data
)
11531 record_unwind_save_match_data ();
11533 /* Make sure that we don't accidentally use bogus keymaps. */
11534 if (NILP (Voverriding_local_map_menu_flag
))
11536 specbind (Qoverriding_terminal_local_map
, Qnil
);
11537 specbind (Qoverriding_local_map
, Qnil
);
11540 GCPRO1 (new_tool_bar
);
11542 /* We must temporarily set the selected frame to this frame
11543 before calling tool_bar_items, because the calculation of
11544 the tool-bar keymap uses the selected frame (see
11545 `tool-bar-make-keymap' in tool-bar.el). */
11546 record_unwind_protect (update_tool_bar_unwind
, selected_frame
);
11547 XSETFRAME (frame
, f
);
11548 selected_frame
= frame
;
11550 /* Build desired tool-bar items from keymaps. */
11552 = tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
11555 /* Redisplay the tool-bar if we changed it. */
11556 if (new_n_tool_bar
!= f
->n_tool_bar_items
11557 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
11559 /* Redisplay that happens asynchronously due to an expose event
11560 may access f->tool_bar_items. Make sure we update both
11561 variables within BLOCK_INPUT so no such event interrupts. */
11563 fset_tool_bar_items (f
, new_tool_bar
);
11564 f
->n_tool_bar_items
= new_n_tool_bar
;
11565 w
->update_mode_line
= 1;
11571 unbind_to (count
, Qnil
);
11572 set_buffer_internal_1 (prev
);
11578 /* Set F->desired_tool_bar_string to a Lisp string representing frame
11579 F's desired tool-bar contents. F->tool_bar_items must have
11580 been set up previously by calling prepare_menu_bars. */
11583 build_desired_tool_bar_string (struct frame
*f
)
11585 int i
, size
, size_needed
;
11586 struct gcpro gcpro1
, gcpro2
, gcpro3
;
11587 Lisp_Object image
, plist
, props
;
11589 image
= plist
= props
= Qnil
;
11590 GCPRO3 (image
, plist
, props
);
11592 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
11593 Otherwise, make a new string. */
11595 /* The size of the string we might be able to reuse. */
11596 size
= (STRINGP (f
->desired_tool_bar_string
)
11597 ? SCHARS (f
->desired_tool_bar_string
)
11600 /* We need one space in the string for each image. */
11601 size_needed
= f
->n_tool_bar_items
;
11603 /* Reuse f->desired_tool_bar_string, if possible. */
11604 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
11605 fset_desired_tool_bar_string
11606 (f
, Fmake_string (make_number (size_needed
), make_number (' ')));
11609 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
11610 Fremove_text_properties (make_number (0), make_number (size
),
11611 props
, f
->desired_tool_bar_string
);
11614 /* Put a `display' property on the string for the images to display,
11615 put a `menu_item' property on tool-bar items with a value that
11616 is the index of the item in F's tool-bar item vector. */
11617 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
11619 #define PROP(IDX) \
11620 AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
11622 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
11623 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
11624 int hmargin
, vmargin
, relief
, idx
, end
;
11626 /* If image is a vector, choose the image according to the
11628 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
11629 if (VECTORP (image
))
11633 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
11634 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
11637 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
11638 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
11640 eassert (ASIZE (image
) >= idx
);
11641 image
= AREF (image
, idx
);
11646 /* Ignore invalid image specifications. */
11647 if (!valid_image_p (image
))
11650 /* Display the tool-bar button pressed, or depressed. */
11651 plist
= Fcopy_sequence (XCDR (image
));
11653 /* Compute margin and relief to draw. */
11654 relief
= (tool_bar_button_relief
>= 0
11655 ? tool_bar_button_relief
11656 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
11657 hmargin
= vmargin
= relief
;
11659 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
,
11660 INT_MAX
- max (hmargin
, vmargin
)))
11662 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
11663 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
11665 else if (CONSP (Vtool_bar_button_margin
))
11667 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
),
11668 INT_MAX
- hmargin
))
11669 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
11671 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
),
11672 INT_MAX
- vmargin
))
11673 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
11676 if (auto_raise_tool_bar_buttons_p
)
11678 /* Add a `:relief' property to the image spec if the item is
11682 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
11689 /* If image is selected, display it pressed, i.e. with a
11690 negative relief. If it's not selected, display it with a
11692 plist
= Fplist_put (plist
, QCrelief
,
11694 ? make_number (-relief
)
11695 : make_number (relief
)));
11700 /* Put a margin around the image. */
11701 if (hmargin
|| vmargin
)
11703 if (hmargin
== vmargin
)
11704 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
11706 plist
= Fplist_put (plist
, QCmargin
,
11707 Fcons (make_number (hmargin
),
11708 make_number (vmargin
)));
11711 /* If button is not enabled, and we don't have special images
11712 for the disabled state, make the image appear disabled by
11713 applying an appropriate algorithm to it. */
11714 if (!enabled_p
&& idx
< 0)
11715 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
11717 /* Put a `display' text property on the string for the image to
11718 display. Put a `menu-item' property on the string that gives
11719 the start of this item's properties in the tool-bar items
11721 image
= Fcons (Qimage
, plist
);
11722 props
= list4 (Qdisplay
, image
,
11723 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
11725 /* Let the last image hide all remaining spaces in the tool bar
11726 string. The string can be longer than needed when we reuse a
11727 previous string. */
11728 if (i
+ 1 == f
->n_tool_bar_items
)
11729 end
= SCHARS (f
->desired_tool_bar_string
);
11732 Fadd_text_properties (make_number (i
), make_number (end
),
11733 props
, f
->desired_tool_bar_string
);
11741 /* Display one line of the tool-bar of frame IT->f.
11743 HEIGHT specifies the desired height of the tool-bar line.
11744 If the actual height of the glyph row is less than HEIGHT, the
11745 row's height is increased to HEIGHT, and the icons are centered
11746 vertically in the new height.
11748 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
11749 count a final empty row in case the tool-bar width exactly matches
11754 display_tool_bar_line (struct it
*it
, int height
)
11756 struct glyph_row
*row
= it
->glyph_row
;
11757 int max_x
= it
->last_visible_x
;
11758 struct glyph
*last
;
11760 prepare_desired_row (row
);
11761 row
->y
= it
->current_y
;
11763 /* Note that this isn't made use of if the face hasn't a box,
11764 so there's no need to check the face here. */
11765 it
->start_of_box_run_p
= 1;
11767 while (it
->current_x
< max_x
)
11769 int x
, n_glyphs_before
, i
, nglyphs
;
11770 struct it it_before
;
11772 /* Get the next display element. */
11773 if (!get_next_display_element (it
))
11775 /* Don't count empty row if we are counting needed tool-bar lines. */
11776 if (height
< 0 && !it
->hpos
)
11781 /* Produce glyphs. */
11782 n_glyphs_before
= row
->used
[TEXT_AREA
];
11785 PRODUCE_GLYPHS (it
);
11787 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
11789 x
= it_before
.current_x
;
11790 while (i
< nglyphs
)
11792 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
11794 if (x
+ glyph
->pixel_width
> max_x
)
11796 /* Glyph doesn't fit on line. Backtrack. */
11797 row
->used
[TEXT_AREA
] = n_glyphs_before
;
11799 /* If this is the only glyph on this line, it will never fit on the
11800 tool-bar, so skip it. But ensure there is at least one glyph,
11801 so we don't accidentally disable the tool-bar. */
11802 if (n_glyphs_before
== 0
11803 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
11809 x
+= glyph
->pixel_width
;
11813 /* Stop at line end. */
11814 if (ITERATOR_AT_END_OF_LINE_P (it
))
11817 set_iterator_to_next (it
, 1);
11822 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
11824 /* Use default face for the border below the tool bar.
11826 FIXME: When auto-resize-tool-bars is grow-only, there is
11827 no additional border below the possibly empty tool-bar lines.
11828 So to make the extra empty lines look "normal", we have to
11829 use the tool-bar face for the border too. */
11830 if (!row
->displays_text_p
&& !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
11831 it
->face_id
= DEFAULT_FACE_ID
;
11833 extend_face_to_end_of_line (it
);
11834 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
11835 last
->right_box_line_p
= 1;
11836 if (last
== row
->glyphs
[TEXT_AREA
])
11837 last
->left_box_line_p
= 1;
11839 /* Make line the desired height and center it vertically. */
11840 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
11842 /* Don't add more than one line height. */
11843 height
%= FRAME_LINE_HEIGHT (it
->f
);
11844 it
->max_ascent
+= height
/ 2;
11845 it
->max_descent
+= (height
+ 1) / 2;
11848 compute_line_metrics (it
);
11850 /* If line is empty, make it occupy the rest of the tool-bar. */
11851 if (!row
->displays_text_p
)
11853 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
11854 row
->visible_height
= row
->height
;
11855 row
->ascent
= row
->phys_ascent
= 0;
11856 row
->extra_line_spacing
= 0;
11859 row
->full_width_p
= 1;
11860 row
->continued_p
= 0;
11861 row
->truncated_on_left_p
= 0;
11862 row
->truncated_on_right_p
= 0;
11864 it
->current_x
= it
->hpos
= 0;
11865 it
->current_y
+= row
->height
;
11871 /* Max tool-bar height. */
11873 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
11874 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
11876 /* Value is the number of screen lines needed to make all tool-bar
11877 items of frame F visible. The number of actual rows needed is
11878 returned in *N_ROWS if non-NULL. */
11881 tool_bar_lines_needed (struct frame
*f
, int *n_rows
)
11883 struct window
*w
= XWINDOW (f
->tool_bar_window
);
11885 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
11886 the desired matrix, so use (unused) mode-line row as temporary row to
11887 avoid destroying the first tool-bar row. */
11888 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
11890 /* Initialize an iterator for iteration over
11891 F->desired_tool_bar_string in the tool-bar window of frame F. */
11892 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
11893 it
.first_visible_x
= 0;
11894 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
11895 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
11896 it
.paragraph_embedding
= L2R
;
11898 while (!ITERATOR_AT_END_P (&it
))
11900 clear_glyph_row (temp_row
);
11901 it
.glyph_row
= temp_row
;
11902 display_tool_bar_line (&it
, -1);
11904 clear_glyph_row (temp_row
);
11906 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
11908 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
11910 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
11914 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
11916 doc
: /* Return the number of lines occupied by the tool bar of FRAME.
11917 If FRAME is nil or omitted, use the selected frame. */)
11918 (Lisp_Object frame
)
11920 struct frame
*f
= decode_any_frame (frame
);
11924 if (WINDOWP (f
->tool_bar_window
)
11925 && (w
= XWINDOW (f
->tool_bar_window
),
11926 WINDOW_TOTAL_LINES (w
) > 0))
11928 update_tool_bar (f
, 1);
11929 if (f
->n_tool_bar_items
)
11931 build_desired_tool_bar_string (f
);
11932 nlines
= tool_bar_lines_needed (f
, NULL
);
11936 return make_number (nlines
);
11940 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
11941 height should be changed. */
11944 redisplay_tool_bar (struct frame
*f
)
11948 struct glyph_row
*row
;
11950 #if defined (USE_GTK) || defined (HAVE_NS)
11951 if (FRAME_EXTERNAL_TOOL_BAR (f
))
11952 update_frame_tool_bar (f
);
11956 /* If frame hasn't a tool-bar window or if it is zero-height, don't
11957 do anything. This means you must start with tool-bar-lines
11958 non-zero to get the auto-sizing effect. Or in other words, you
11959 can turn off tool-bars by specifying tool-bar-lines zero. */
11960 if (!WINDOWP (f
->tool_bar_window
)
11961 || (w
= XWINDOW (f
->tool_bar_window
),
11962 WINDOW_TOTAL_LINES (w
) == 0))
11965 /* Set up an iterator for the tool-bar window. */
11966 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
11967 it
.first_visible_x
= 0;
11968 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
11969 row
= it
.glyph_row
;
11971 /* Build a string that represents the contents of the tool-bar. */
11972 build_desired_tool_bar_string (f
);
11973 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
11974 /* FIXME: This should be controlled by a user option. But it
11975 doesn't make sense to have an R2L tool bar if the menu bar cannot
11976 be drawn also R2L, and making the menu bar R2L is tricky due
11977 toolkit-specific code that implements it. If an R2L tool bar is
11978 ever supported, display_tool_bar_line should also be augmented to
11979 call unproduce_glyphs like display_line and display_string
11981 it
.paragraph_embedding
= L2R
;
11983 if (f
->n_tool_bar_rows
== 0)
11987 if ((nlines
= tool_bar_lines_needed (f
, &f
->n_tool_bar_rows
),
11988 nlines
!= WINDOW_TOTAL_LINES (w
)))
11991 int old_height
= WINDOW_TOTAL_LINES (w
);
11993 XSETFRAME (frame
, f
);
11994 Fmodify_frame_parameters (frame
,
11995 Fcons (Fcons (Qtool_bar_lines
,
11996 make_number (nlines
)),
11998 if (WINDOW_TOTAL_LINES (w
) != old_height
)
12000 clear_glyph_matrix (w
->desired_matrix
);
12001 fonts_changed_p
= 1;
12007 /* Display as many lines as needed to display all tool-bar items. */
12009 if (f
->n_tool_bar_rows
> 0)
12011 int border
, rows
, height
, extra
;
12013 if (TYPE_RANGED_INTEGERP (int, Vtool_bar_border
))
12014 border
= XINT (Vtool_bar_border
);
12015 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
12016 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
12017 else if (EQ (Vtool_bar_border
, Qborder_width
))
12018 border
= f
->border_width
;
12024 rows
= f
->n_tool_bar_rows
;
12025 height
= max (1, (it
.last_visible_y
- border
) / rows
);
12026 extra
= it
.last_visible_y
- border
- height
* rows
;
12028 while (it
.current_y
< it
.last_visible_y
)
12031 if (extra
> 0 && rows
-- > 0)
12033 h
= (extra
+ rows
- 1) / rows
;
12036 display_tool_bar_line (&it
, height
+ h
);
12041 while (it
.current_y
< it
.last_visible_y
)
12042 display_tool_bar_line (&it
, 0);
12045 /* It doesn't make much sense to try scrolling in the tool-bar
12046 window, so don't do it. */
12047 w
->desired_matrix
->no_scrolling_p
= 1;
12048 w
->must_be_updated_p
= 1;
12050 if (!NILP (Vauto_resize_tool_bars
))
12052 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
12053 int change_height_p
= 0;
12055 /* If we couldn't display everything, change the tool-bar's
12056 height if there is room for more. */
12057 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
12058 && it
.current_y
< max_tool_bar_height
)
12059 change_height_p
= 1;
12061 row
= it
.glyph_row
- 1;
12063 /* If there are blank lines at the end, except for a partially
12064 visible blank line at the end that is smaller than
12065 FRAME_LINE_HEIGHT, change the tool-bar's height. */
12066 if (!row
->displays_text_p
12067 && row
->height
>= FRAME_LINE_HEIGHT (f
))
12068 change_height_p
= 1;
12070 /* If row displays tool-bar items, but is partially visible,
12071 change the tool-bar's height. */
12072 if (row
->displays_text_p
12073 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
12074 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
12075 change_height_p
= 1;
12077 /* Resize windows as needed by changing the `tool-bar-lines'
12078 frame parameter. */
12079 if (change_height_p
)
12082 int old_height
= WINDOW_TOTAL_LINES (w
);
12084 int nlines
= tool_bar_lines_needed (f
, &nrows
);
12086 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
12087 && !f
->minimize_tool_bar_window_p
)
12088 ? (nlines
> old_height
)
12089 : (nlines
!= old_height
));
12090 f
->minimize_tool_bar_window_p
= 0;
12092 if (change_height_p
)
12094 XSETFRAME (frame
, f
);
12095 Fmodify_frame_parameters (frame
,
12096 Fcons (Fcons (Qtool_bar_lines
,
12097 make_number (nlines
)),
12099 if (WINDOW_TOTAL_LINES (w
) != old_height
)
12101 clear_glyph_matrix (w
->desired_matrix
);
12102 f
->n_tool_bar_rows
= nrows
;
12103 fonts_changed_p
= 1;
12110 f
->minimize_tool_bar_window_p
= 0;
12115 /* Get information about the tool-bar item which is displayed in GLYPH
12116 on frame F. Return in *PROP_IDX the index where tool-bar item
12117 properties start in F->tool_bar_items. Value is zero if
12118 GLYPH doesn't display a tool-bar item. */
12121 tool_bar_item_info (struct frame
*f
, struct glyph
*glyph
, int *prop_idx
)
12127 /* This function can be called asynchronously, which means we must
12128 exclude any possibility that Fget_text_property signals an
12130 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
12131 charpos
= max (0, charpos
);
12133 /* Get the text property `menu-item' at pos. The value of that
12134 property is the start index of this item's properties in
12135 F->tool_bar_items. */
12136 prop
= Fget_text_property (make_number (charpos
),
12137 Qmenu_item
, f
->current_tool_bar_string
);
12138 if (INTEGERP (prop
))
12140 *prop_idx
= XINT (prop
);
12150 /* Get information about the tool-bar item at position X/Y on frame F.
12151 Return in *GLYPH a pointer to the glyph of the tool-bar item in
12152 the current matrix of the tool-bar window of F, or NULL if not
12153 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
12154 item in F->tool_bar_items. Value is
12156 -1 if X/Y is not on a tool-bar item
12157 0 if X/Y is on the same item that was highlighted before.
12161 get_tool_bar_item (struct frame
*f
, int x
, int y
, struct glyph
**glyph
,
12162 int *hpos
, int *vpos
, int *prop_idx
)
12164 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12165 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12168 /* Find the glyph under X/Y. */
12169 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
12170 if (*glyph
== NULL
)
12173 /* Get the start of this tool-bar item's properties in
12174 f->tool_bar_items. */
12175 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
12178 /* Is mouse on the highlighted item? */
12179 if (EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)
12180 && *vpos
>= hlinfo
->mouse_face_beg_row
12181 && *vpos
<= hlinfo
->mouse_face_end_row
12182 && (*vpos
> hlinfo
->mouse_face_beg_row
12183 || *hpos
>= hlinfo
->mouse_face_beg_col
)
12184 && (*vpos
< hlinfo
->mouse_face_end_row
12185 || *hpos
< hlinfo
->mouse_face_end_col
12186 || hlinfo
->mouse_face_past_end
))
12194 Handle mouse button event on the tool-bar of frame F, at
12195 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
12196 0 for button release. MODIFIERS is event modifiers for button
12200 handle_tool_bar_click (struct frame
*f
, int x
, int y
, int down_p
,
12203 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12204 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12205 int hpos
, vpos
, prop_idx
;
12206 struct glyph
*glyph
;
12207 Lisp_Object enabled_p
;
12209 /* If not on the highlighted tool-bar item, return. */
12210 frame_to_window_pixel_xy (w
, &x
, &y
);
12211 if (get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
12214 /* If item is disabled, do nothing. */
12215 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12216 if (NILP (enabled_p
))
12221 /* Show item in pressed state. */
12222 show_mouse_face (hlinfo
, DRAW_IMAGE_SUNKEN
);
12223 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
12224 last_tool_bar_item
= prop_idx
;
12228 Lisp_Object key
, frame
;
12229 struct input_event event
;
12230 EVENT_INIT (event
);
12232 /* Show item in released state. */
12233 show_mouse_face (hlinfo
, DRAW_IMAGE_RAISED
);
12234 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
12236 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
12238 XSETFRAME (frame
, f
);
12239 event
.kind
= TOOL_BAR_EVENT
;
12240 event
.frame_or_window
= frame
;
12242 kbd_buffer_store_event (&event
);
12244 event
.kind
= TOOL_BAR_EVENT
;
12245 event
.frame_or_window
= frame
;
12247 event
.modifiers
= modifiers
;
12248 kbd_buffer_store_event (&event
);
12249 last_tool_bar_item
= -1;
12254 /* Possibly highlight a tool-bar item on frame F when mouse moves to
12255 tool-bar window-relative coordinates X/Y. Called from
12256 note_mouse_highlight. */
12259 note_tool_bar_highlight (struct frame
*f
, int x
, int y
)
12261 Lisp_Object window
= f
->tool_bar_window
;
12262 struct window
*w
= XWINDOW (window
);
12263 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12264 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12266 struct glyph
*glyph
;
12267 struct glyph_row
*row
;
12269 Lisp_Object enabled_p
;
12271 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
12272 int mouse_down_p
, rc
;
12274 /* Function note_mouse_highlight is called with negative X/Y
12275 values when mouse moves outside of the frame. */
12276 if (x
<= 0 || y
<= 0)
12278 clear_mouse_face (hlinfo
);
12282 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
12285 /* Not on tool-bar item. */
12286 clear_mouse_face (hlinfo
);
12290 /* On same tool-bar item as before. */
12291 goto set_help_echo
;
12293 clear_mouse_face (hlinfo
);
12295 /* Mouse is down, but on different tool-bar item? */
12296 mouse_down_p
= (dpyinfo
->grabbed
12297 && f
== last_mouse_frame
12298 && FRAME_LIVE_P (f
));
12300 && last_tool_bar_item
!= prop_idx
)
12303 hlinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
12304 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
12306 /* If tool-bar item is not enabled, don't highlight it. */
12307 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12308 if (!NILP (enabled_p
))
12310 /* Compute the x-position of the glyph. In front and past the
12311 image is a space. We include this in the highlighted area. */
12312 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
12313 for (i
= x
= 0; i
< hpos
; ++i
)
12314 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
12316 /* Record this as the current active region. */
12317 hlinfo
->mouse_face_beg_col
= hpos
;
12318 hlinfo
->mouse_face_beg_row
= vpos
;
12319 hlinfo
->mouse_face_beg_x
= x
;
12320 hlinfo
->mouse_face_beg_y
= row
->y
;
12321 hlinfo
->mouse_face_past_end
= 0;
12323 hlinfo
->mouse_face_end_col
= hpos
+ 1;
12324 hlinfo
->mouse_face_end_row
= vpos
;
12325 hlinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
12326 hlinfo
->mouse_face_end_y
= row
->y
;
12327 hlinfo
->mouse_face_window
= window
;
12328 hlinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
12330 /* Display it as active. */
12331 show_mouse_face (hlinfo
, draw
);
12332 hlinfo
->mouse_face_image_state
= draw
;
12337 /* Set help_echo_string to a help string to display for this tool-bar item.
12338 XTread_socket does the rest. */
12339 help_echo_object
= help_echo_window
= Qnil
;
12340 help_echo_pos
= -1;
12341 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
12342 if (NILP (help_echo_string
))
12343 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
12346 #endif /* HAVE_WINDOW_SYSTEM */
12350 /************************************************************************
12351 Horizontal scrolling
12352 ************************************************************************/
12354 static int hscroll_window_tree (Lisp_Object
);
12355 static int hscroll_windows (Lisp_Object
);
12357 /* For all leaf windows in the window tree rooted at WINDOW, set their
12358 hscroll value so that PT is (i) visible in the window, and (ii) so
12359 that it is not within a certain margin at the window's left and
12360 right border. Value is non-zero if any window's hscroll has been
12364 hscroll_window_tree (Lisp_Object window
)
12366 int hscrolled_p
= 0;
12367 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
12368 int hscroll_step_abs
= 0;
12369 double hscroll_step_rel
= 0;
12371 if (hscroll_relative_p
)
12373 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
12374 if (hscroll_step_rel
< 0)
12376 hscroll_relative_p
= 0;
12377 hscroll_step_abs
= 0;
12380 else if (TYPE_RANGED_INTEGERP (int, Vhscroll_step
))
12382 hscroll_step_abs
= XINT (Vhscroll_step
);
12383 if (hscroll_step_abs
< 0)
12384 hscroll_step_abs
= 0;
12387 hscroll_step_abs
= 0;
12389 while (WINDOWP (window
))
12391 struct window
*w
= XWINDOW (window
);
12393 if (WINDOWP (w
->hchild
))
12394 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
12395 else if (WINDOWP (w
->vchild
))
12396 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
12397 else if (w
->cursor
.vpos
>= 0)
12400 int text_area_width
;
12401 struct glyph_row
*current_cursor_row
12402 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
12403 struct glyph_row
*desired_cursor_row
12404 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
12405 struct glyph_row
*cursor_row
12406 = (desired_cursor_row
->enabled_p
12407 ? desired_cursor_row
12408 : current_cursor_row
);
12409 int row_r2l_p
= cursor_row
->reversed_p
;
12411 text_area_width
= window_box_width (w
, TEXT_AREA
);
12413 /* Scroll when cursor is inside this scroll margin. */
12414 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
12416 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode
, w
->buffer
))
12417 /* For left-to-right rows, hscroll when cursor is either
12418 (i) inside the right hscroll margin, or (ii) if it is
12419 inside the left margin and the window is already
12423 && w
->cursor
.x
<= h_margin
)
12424 || (cursor_row
->enabled_p
12425 && cursor_row
->truncated_on_right_p
12426 && (w
->cursor
.x
>= text_area_width
- h_margin
))))
12427 /* For right-to-left rows, the logic is similar,
12428 except that rules for scrolling to left and right
12429 are reversed. E.g., if cursor.x <= h_margin, we
12430 need to hscroll "to the right" unconditionally,
12431 and that will scroll the screen to the left so as
12432 to reveal the next portion of the row. */
12434 && ((cursor_row
->enabled_p
12435 /* FIXME: It is confusing to set the
12436 truncated_on_right_p flag when R2L rows
12437 are actually truncated on the left. */
12438 && cursor_row
->truncated_on_right_p
12439 && w
->cursor
.x
<= h_margin
)
12441 && (w
->cursor
.x
>= text_area_width
- h_margin
))))))
12445 struct buffer
*saved_current_buffer
;
12449 /* Find point in a display of infinite width. */
12450 saved_current_buffer
= current_buffer
;
12451 current_buffer
= XBUFFER (w
->buffer
);
12453 if (w
== XWINDOW (selected_window
))
12457 pt
= marker_position (w
->pointm
);
12458 pt
= max (BEGV
, pt
);
12462 /* Move iterator to pt starting at cursor_row->start in
12463 a line with infinite width. */
12464 init_to_row_start (&it
, w
, cursor_row
);
12465 it
.last_visible_x
= INFINITY
;
12466 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
12467 current_buffer
= saved_current_buffer
;
12469 /* Position cursor in window. */
12470 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
12471 hscroll
= max (0, (it
.current_x
12472 - (ITERATOR_AT_END_OF_LINE_P (&it
)
12473 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
12474 : (text_area_width
/ 2))))
12475 / FRAME_COLUMN_WIDTH (it
.f
);
12476 else if ((!row_r2l_p
12477 && w
->cursor
.x
>= text_area_width
- h_margin
)
12478 || (row_r2l_p
&& w
->cursor
.x
<= h_margin
))
12480 if (hscroll_relative_p
)
12481 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
12484 wanted_x
= text_area_width
12485 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12488 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12492 if (hscroll_relative_p
)
12493 wanted_x
= text_area_width
* hscroll_step_rel
12496 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12499 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12501 hscroll
= max (hscroll
, w
->min_hscroll
);
12503 /* Don't prevent redisplay optimizations if hscroll
12504 hasn't changed, as it will unnecessarily slow down
12506 if (w
->hscroll
!= hscroll
)
12508 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
12509 w
->hscroll
= hscroll
;
12518 /* Value is non-zero if hscroll of any leaf window has been changed. */
12519 return hscrolled_p
;
12523 /* Set hscroll so that cursor is visible and not inside horizontal
12524 scroll margins for all windows in the tree rooted at WINDOW. See
12525 also hscroll_window_tree above. Value is non-zero if any window's
12526 hscroll has been changed. If it has, desired matrices on the frame
12527 of WINDOW are cleared. */
12530 hscroll_windows (Lisp_Object window
)
12532 int hscrolled_p
= hscroll_window_tree (window
);
12534 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
12535 return hscrolled_p
;
12540 /************************************************************************
12542 ************************************************************************/
12544 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
12545 to a non-zero value. This is sometimes handy to have in a debugger
12550 /* First and last unchanged row for try_window_id. */
12552 static int debug_first_unchanged_at_end_vpos
;
12553 static int debug_last_unchanged_at_beg_vpos
;
12555 /* Delta vpos and y. */
12557 static int debug_dvpos
, debug_dy
;
12559 /* Delta in characters and bytes for try_window_id. */
12561 static ptrdiff_t debug_delta
, debug_delta_bytes
;
12563 /* Values of window_end_pos and window_end_vpos at the end of
12566 static ptrdiff_t debug_end_vpos
;
12568 /* Append a string to W->desired_matrix->method. FMT is a printf
12569 format string. If trace_redisplay_p is non-zero also printf the
12570 resulting string to stderr. */
12572 static void debug_method_add (struct window
*, char const *, ...)
12573 ATTRIBUTE_FORMAT_PRINTF (2, 3);
12576 debug_method_add (struct window
*w
, char const *fmt
, ...)
12578 char *method
= w
->desired_matrix
->method
;
12579 int len
= strlen (method
);
12580 int size
= sizeof w
->desired_matrix
->method
;
12581 int remaining
= size
- len
- 1;
12584 if (len
&& remaining
)
12587 --remaining
, ++len
;
12590 va_start (ap
, fmt
);
12591 vsnprintf (method
+ len
, remaining
+ 1, fmt
, ap
);
12594 if (trace_redisplay_p
)
12595 fprintf (stderr
, "%p (%s): %s\n",
12597 ((BUFFERP (w
->buffer
)
12598 && STRINGP (BVAR (XBUFFER (w
->buffer
), name
)))
12599 ? SSDATA (BVAR (XBUFFER (w
->buffer
), name
))
12604 #endif /* GLYPH_DEBUG */
12607 /* Value is non-zero if all changes in window W, which displays
12608 current_buffer, are in the text between START and END. START is a
12609 buffer position, END is given as a distance from Z. Used in
12610 redisplay_internal for display optimization. */
12613 text_outside_line_unchanged_p (struct window
*w
,
12614 ptrdiff_t start
, ptrdiff_t end
)
12616 int unchanged_p
= 1;
12618 /* If text or overlays have changed, see where. */
12619 if (w
->last_modified
< MODIFF
12620 || w
->last_overlay_modified
< OVERLAY_MODIFF
)
12622 /* Gap in the line? */
12623 if (GPT
< start
|| Z
- GPT
< end
)
12626 /* Changes start in front of the line, or end after it? */
12628 && (BEG_UNCHANGED
< start
- 1
12629 || END_UNCHANGED
< end
))
12632 /* If selective display, can't optimize if changes start at the
12633 beginning of the line. */
12635 && INTEGERP (BVAR (current_buffer
, selective_display
))
12636 && XINT (BVAR (current_buffer
, selective_display
)) > 0
12637 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
12640 /* If there are overlays at the start or end of the line, these
12641 may have overlay strings with newlines in them. A change at
12642 START, for instance, may actually concern the display of such
12643 overlay strings as well, and they are displayed on different
12644 lines. So, quickly rule out this case. (For the future, it
12645 might be desirable to implement something more telling than
12646 just BEG/END_UNCHANGED.) */
12649 if (BEG
+ BEG_UNCHANGED
== start
12650 && overlay_touches_p (start
))
12652 if (END_UNCHANGED
== end
12653 && overlay_touches_p (Z
- end
))
12657 /* Under bidi reordering, adding or deleting a character in the
12658 beginning of a paragraph, before the first strong directional
12659 character, can change the base direction of the paragraph (unless
12660 the buffer specifies a fixed paragraph direction), which will
12661 require to redisplay the whole paragraph. It might be worthwhile
12662 to find the paragraph limits and widen the range of redisplayed
12663 lines to that, but for now just give up this optimization. */
12664 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
12665 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
12669 return unchanged_p
;
12673 /* Do a frame update, taking possible shortcuts into account. This is
12674 the main external entry point for redisplay.
12676 If the last redisplay displayed an echo area message and that message
12677 is no longer requested, we clear the echo area or bring back the
12678 mini-buffer if that is in use. */
12683 redisplay_internal ();
12688 overlay_arrow_string_or_property (Lisp_Object var
)
12692 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
12695 return Voverlay_arrow_string
;
12698 /* Return 1 if there are any overlay-arrows in current_buffer. */
12700 overlay_arrow_in_current_buffer_p (void)
12704 for (vlist
= Voverlay_arrow_variable_list
;
12706 vlist
= XCDR (vlist
))
12708 Lisp_Object var
= XCAR (vlist
);
12711 if (!SYMBOLP (var
))
12713 val
= find_symbol_value (var
);
12715 && current_buffer
== XMARKER (val
)->buffer
)
12722 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
12726 overlay_arrows_changed_p (void)
12730 for (vlist
= Voverlay_arrow_variable_list
;
12732 vlist
= XCDR (vlist
))
12734 Lisp_Object var
= XCAR (vlist
);
12735 Lisp_Object val
, pstr
;
12737 if (!SYMBOLP (var
))
12739 val
= find_symbol_value (var
);
12740 if (!MARKERP (val
))
12742 if (! EQ (COERCE_MARKER (val
),
12743 Fget (var
, Qlast_arrow_position
))
12744 || ! (pstr
= overlay_arrow_string_or_property (var
),
12745 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
12751 /* Mark overlay arrows to be updated on next redisplay. */
12754 update_overlay_arrows (int up_to_date
)
12758 for (vlist
= Voverlay_arrow_variable_list
;
12760 vlist
= XCDR (vlist
))
12762 Lisp_Object var
= XCAR (vlist
);
12764 if (!SYMBOLP (var
))
12767 if (up_to_date
> 0)
12769 Lisp_Object val
= find_symbol_value (var
);
12770 Fput (var
, Qlast_arrow_position
,
12771 COERCE_MARKER (val
));
12772 Fput (var
, Qlast_arrow_string
,
12773 overlay_arrow_string_or_property (var
));
12775 else if (up_to_date
< 0
12776 || !NILP (Fget (var
, Qlast_arrow_position
)))
12778 Fput (var
, Qlast_arrow_position
, Qt
);
12779 Fput (var
, Qlast_arrow_string
, Qt
);
12785 /* Return overlay arrow string to display at row.
12786 Return integer (bitmap number) for arrow bitmap in left fringe.
12787 Return nil if no overlay arrow. */
12790 overlay_arrow_at_row (struct it
*it
, struct glyph_row
*row
)
12794 for (vlist
= Voverlay_arrow_variable_list
;
12796 vlist
= XCDR (vlist
))
12798 Lisp_Object var
= XCAR (vlist
);
12801 if (!SYMBOLP (var
))
12804 val
= find_symbol_value (var
);
12807 && current_buffer
== XMARKER (val
)->buffer
12808 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
12810 if (FRAME_WINDOW_P (it
->f
)
12811 /* FIXME: if ROW->reversed_p is set, this should test
12812 the right fringe, not the left one. */
12813 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
12815 #ifdef HAVE_WINDOW_SYSTEM
12816 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
12819 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
12820 return make_number (fringe_bitmap
);
12823 return make_number (-1); /* Use default arrow bitmap. */
12825 return overlay_arrow_string_or_property (var
);
12832 /* Return 1 if point moved out of or into a composition. Otherwise
12833 return 0. PREV_BUF and PREV_PT are the last point buffer and
12834 position. BUF and PT are the current point buffer and position. */
12837 check_point_in_composition (struct buffer
*prev_buf
, ptrdiff_t prev_pt
,
12838 struct buffer
*buf
, ptrdiff_t pt
)
12840 ptrdiff_t start
, end
;
12842 Lisp_Object buffer
;
12844 XSETBUFFER (buffer
, buf
);
12845 /* Check a composition at the last point if point moved within the
12847 if (prev_buf
== buf
)
12850 /* Point didn't move. */
12853 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
12854 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
12855 && COMPOSITION_VALID_P (start
, end
, prop
)
12856 && start
< prev_pt
&& end
> prev_pt
)
12857 /* The last point was within the composition. Return 1 iff
12858 point moved out of the composition. */
12859 return (pt
<= start
|| pt
>= end
);
12862 /* Check a composition at the current point. */
12863 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
12864 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
12865 && COMPOSITION_VALID_P (start
, end
, prop
)
12866 && start
< pt
&& end
> pt
);
12870 /* Reconsider the setting of B->clip_changed which is displayed
12874 reconsider_clip_changes (struct window
*w
, struct buffer
*b
)
12876 if (b
->clip_changed
12877 && !NILP (w
->window_end_valid
)
12878 && w
->current_matrix
->buffer
== b
12879 && w
->current_matrix
->zv
== BUF_ZV (b
)
12880 && w
->current_matrix
->begv
== BUF_BEGV (b
))
12881 b
->clip_changed
= 0;
12883 /* If display wasn't paused, and W is not a tool bar window, see if
12884 point has been moved into or out of a composition. In that case,
12885 we set b->clip_changed to 1 to force updating the screen. If
12886 b->clip_changed has already been set to 1, we can skip this
12888 if (!b
->clip_changed
12889 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
12893 if (w
== XWINDOW (selected_window
))
12896 pt
= marker_position (w
->pointm
);
12898 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
12899 || pt
!= w
->last_point
)
12900 && check_point_in_composition (w
->current_matrix
->buffer
,
12902 XBUFFER (w
->buffer
), pt
))
12903 b
->clip_changed
= 1;
12908 /* Select FRAME to forward the values of frame-local variables into C
12909 variables so that the redisplay routines can access those values
12913 select_frame_for_redisplay (Lisp_Object frame
)
12915 Lisp_Object tail
, tem
;
12916 Lisp_Object old
= selected_frame
;
12917 struct Lisp_Symbol
*sym
;
12919 eassert (FRAMEP (frame
) && FRAME_LIVE_P (XFRAME (frame
)));
12921 selected_frame
= frame
;
12924 for (tail
= XFRAME (frame
)->param_alist
;
12925 CONSP (tail
); tail
= XCDR (tail
))
12926 if (CONSP (XCAR (tail
))
12927 && (tem
= XCAR (XCAR (tail
)),
12929 && (sym
= indirect_variable (XSYMBOL (tem
)),
12930 sym
->redirect
== SYMBOL_LOCALIZED
)
12931 && sym
->val
.blv
->frame_local
)
12932 /* Use find_symbol_value rather than Fsymbol_value
12933 to avoid an error if it is void. */
12934 find_symbol_value (tem
);
12935 } while (!EQ (frame
, old
) && (frame
= old
, 1));
12939 #define STOP_POLLING \
12940 do { if (! polling_stopped_here) stop_polling (); \
12941 polling_stopped_here = 1; } while (0)
12943 #define RESUME_POLLING \
12944 do { if (polling_stopped_here) start_polling (); \
12945 polling_stopped_here = 0; } while (0)
12948 /* Perhaps in the future avoid recentering windows if it
12949 is not necessary; currently that causes some problems. */
12952 redisplay_internal (void)
12954 struct window
*w
= XWINDOW (selected_window
);
12958 int must_finish
= 0;
12959 struct text_pos tlbufpos
, tlendpos
;
12960 int number_of_visible_frames
;
12961 ptrdiff_t count
, count1
;
12963 int polling_stopped_here
= 0;
12964 Lisp_Object old_frame
= selected_frame
;
12965 struct backtrace backtrace
;
12967 /* Non-zero means redisplay has to consider all windows on all
12968 frames. Zero means, only selected_window is considered. */
12969 int consider_all_windows_p
;
12971 /* Non-zero means redisplay has to redisplay the miniwindow. */
12972 int update_miniwindow_p
= 0;
12974 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
12976 /* No redisplay if running in batch mode or frame is not yet fully
12977 initialized, or redisplay is explicitly turned off by setting
12978 Vinhibit_redisplay. */
12979 if (FRAME_INITIAL_P (SELECTED_FRAME ())
12980 || !NILP (Vinhibit_redisplay
))
12983 /* Don't examine these until after testing Vinhibit_redisplay.
12984 When Emacs is shutting down, perhaps because its connection to
12985 X has dropped, we should not look at them at all. */
12986 fr
= XFRAME (w
->frame
);
12987 sf
= SELECTED_FRAME ();
12989 if (!fr
->glyphs_initialized_p
)
12992 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
12993 if (popup_activated ())
12997 /* I don't think this happens but let's be paranoid. */
12998 if (redisplaying_p
)
13001 /* Record a function that clears redisplaying_p
13002 when we leave this function. */
13003 count
= SPECPDL_INDEX ();
13004 record_unwind_protect (unwind_redisplay
, selected_frame
);
13005 redisplaying_p
= 1;
13006 specbind (Qinhibit_free_realized_faces
, Qnil
);
13008 /* Record this function, so it appears on the profiler's backtraces. */
13009 backtrace
.next
= backtrace_list
;
13010 backtrace
.function
= Qredisplay_internal
;
13011 backtrace
.args
= &Qnil
;
13012 backtrace
.nargs
= 0;
13013 backtrace
.debug_on_exit
= 0;
13014 backtrace_list
= &backtrace
;
13017 Lisp_Object tail
, frame
;
13019 FOR_EACH_FRAME (tail
, frame
)
13021 struct frame
*f
= XFRAME (frame
);
13022 f
->already_hscrolled_p
= 0;
13027 /* Remember the currently selected window. */
13030 if (!EQ (old_frame
, selected_frame
)
13031 && FRAME_LIVE_P (XFRAME (old_frame
)))
13032 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
13033 selected_frame and selected_window to be temporarily out-of-sync so
13034 when we come back here via `goto retry', we need to resync because we
13035 may need to run Elisp code (via prepare_menu_bars). */
13036 select_frame_for_redisplay (old_frame
);
13039 reconsider_clip_changes (w
, current_buffer
);
13040 last_escape_glyph_frame
= NULL
;
13041 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
13042 last_glyphless_glyph_frame
= NULL
;
13043 last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
13045 /* If new fonts have been loaded that make a glyph matrix adjustment
13046 necessary, do it. */
13047 if (fonts_changed_p
)
13049 adjust_glyphs (NULL
);
13050 ++windows_or_buffers_changed
;
13051 fonts_changed_p
= 0;
13054 /* If face_change_count is non-zero, init_iterator will free all
13055 realized faces, which includes the faces referenced from current
13056 matrices. So, we can't reuse current matrices in this case. */
13057 if (face_change_count
)
13058 ++windows_or_buffers_changed
;
13060 if ((FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
13061 && FRAME_TTY (sf
)->previous_frame
!= sf
)
13063 /* Since frames on a single ASCII terminal share the same
13064 display area, displaying a different frame means redisplay
13065 the whole thing. */
13066 windows_or_buffers_changed
++;
13067 SET_FRAME_GARBAGED (sf
);
13069 set_tty_color_mode (FRAME_TTY (sf
), sf
);
13071 FRAME_TTY (sf
)->previous_frame
= sf
;
13074 /* Set the visible flags for all frames. Do this before checking
13075 for resized or garbaged frames; they want to know if their frames
13076 are visible. See the comment in frame.h for
13077 FRAME_SAMPLE_VISIBILITY. */
13079 Lisp_Object tail
, frame
;
13081 number_of_visible_frames
= 0;
13083 FOR_EACH_FRAME (tail
, frame
)
13085 struct frame
*f
= XFRAME (frame
);
13087 FRAME_SAMPLE_VISIBILITY (f
);
13088 if (FRAME_VISIBLE_P (f
))
13089 ++number_of_visible_frames
;
13090 clear_desired_matrices (f
);
13094 /* Notice any pending interrupt request to change frame size. */
13095 do_pending_window_change (1);
13097 /* do_pending_window_change could change the selected_window due to
13098 frame resizing which makes the selected window too small. */
13099 if (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
)
13102 reconsider_clip_changes (w
, current_buffer
);
13105 /* Clear frames marked as garbaged. */
13106 clear_garbaged_frames ();
13108 /* Build menubar and tool-bar items. */
13109 if (NILP (Vmemory_full
))
13110 prepare_menu_bars ();
13112 if (windows_or_buffers_changed
)
13113 update_mode_lines
++;
13115 /* Detect case that we need to write or remove a star in the mode line. */
13116 if ((SAVE_MODIFF
< MODIFF
) != w
->last_had_star
)
13118 w
->update_mode_line
= 1;
13119 if (buffer_shared
> 1)
13120 update_mode_lines
++;
13123 /* Avoid invocation of point motion hooks by `current_column' below. */
13124 count1
= SPECPDL_INDEX ();
13125 specbind (Qinhibit_point_motion_hooks
, Qt
);
13127 /* If %c is in the mode line, update it if needed. */
13128 if (!NILP (w
->column_number_displayed
)
13129 /* This alternative quickly identifies a common case
13130 where no change is needed. */
13131 && !(PT
== w
->last_point
13132 && w
->last_modified
>= MODIFF
13133 && w
->last_overlay_modified
>= OVERLAY_MODIFF
)
13134 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
13135 w
->update_mode_line
= 1;
13137 unbind_to (count1
, Qnil
);
13139 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
13141 /* The variable buffer_shared is set in redisplay_window and
13142 indicates that we redisplay a buffer in different windows. See
13144 consider_all_windows_p
= (update_mode_lines
|| buffer_shared
> 1
13145 || cursor_type_changed
);
13147 /* If specs for an arrow have changed, do thorough redisplay
13148 to ensure we remove any arrow that should no longer exist. */
13149 if (overlay_arrows_changed_p ())
13150 consider_all_windows_p
= windows_or_buffers_changed
= 1;
13152 /* Normally the message* functions will have already displayed and
13153 updated the echo area, but the frame may have been trashed, or
13154 the update may have been preempted, so display the echo area
13155 again here. Checking message_cleared_p captures the case that
13156 the echo area should be cleared. */
13157 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
13158 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
13159 || (message_cleared_p
13160 && minibuf_level
== 0
13161 /* If the mini-window is currently selected, this means the
13162 echo-area doesn't show through. */
13163 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
13165 int window_height_changed_p
= echo_area_display (0);
13167 if (message_cleared_p
)
13168 update_miniwindow_p
= 1;
13172 /* If we don't display the current message, don't clear the
13173 message_cleared_p flag, because, if we did, we wouldn't clear
13174 the echo area in the next redisplay which doesn't preserve
13176 if (!display_last_displayed_message_p
)
13177 message_cleared_p
= 0;
13179 if (fonts_changed_p
)
13181 else if (window_height_changed_p
)
13183 consider_all_windows_p
= 1;
13184 ++update_mode_lines
;
13185 ++windows_or_buffers_changed
;
13187 /* If window configuration was changed, frames may have been
13188 marked garbaged. Clear them or we will experience
13189 surprises wrt scrolling. */
13190 clear_garbaged_frames ();
13193 else if (EQ (selected_window
, minibuf_window
)
13194 && (current_buffer
->clip_changed
13195 || w
->last_modified
< MODIFF
13196 || w
->last_overlay_modified
< OVERLAY_MODIFF
)
13197 && resize_mini_window (w
, 0))
13199 /* Resized active mini-window to fit the size of what it is
13200 showing if its contents might have changed. */
13202 /* FIXME: this causes all frames to be updated, which seems unnecessary
13203 since only the current frame needs to be considered. This function needs
13204 to be rewritten with two variables, consider_all_windows and
13205 consider_all_frames. */
13206 consider_all_windows_p
= 1;
13207 ++windows_or_buffers_changed
;
13208 ++update_mode_lines
;
13210 /* If window configuration was changed, frames may have been
13211 marked garbaged. Clear them or we will experience
13212 surprises wrt scrolling. */
13213 clear_garbaged_frames ();
13217 /* If showing the region, and mark has changed, we must redisplay
13218 the whole window. The assignment to this_line_start_pos prevents
13219 the optimization directly below this if-statement. */
13220 if (((!NILP (Vtransient_mark_mode
)
13221 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
13222 != !NILP (w
->region_showing
))
13223 || (!NILP (w
->region_showing
)
13224 && !EQ (w
->region_showing
,
13225 Fmarker_position (BVAR (XBUFFER (w
->buffer
), mark
)))))
13226 CHARPOS (this_line_start_pos
) = 0;
13228 /* Optimize the case that only the line containing the cursor in the
13229 selected window has changed. Variables starting with this_ are
13230 set in display_line and record information about the line
13231 containing the cursor. */
13232 tlbufpos
= this_line_start_pos
;
13233 tlendpos
= this_line_end_pos
;
13234 if (!consider_all_windows_p
13235 && CHARPOS (tlbufpos
) > 0
13236 && !w
->update_mode_line
13237 && !current_buffer
->clip_changed
13238 && !current_buffer
->prevent_redisplay_optimizations_p
13239 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
13240 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
13241 /* Make sure recorded data applies to current buffer, etc. */
13242 && this_line_buffer
== current_buffer
13243 && current_buffer
== XBUFFER (w
->buffer
)
13245 && !w
->optional_new_start
13246 /* Point must be on the line that we have info recorded about. */
13247 && PT
>= CHARPOS (tlbufpos
)
13248 && PT
<= Z
- CHARPOS (tlendpos
)
13249 /* All text outside that line, including its final newline,
13250 must be unchanged. */
13251 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
13252 CHARPOS (tlendpos
)))
13254 if (CHARPOS (tlbufpos
) > BEGV
13255 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
13256 && (CHARPOS (tlbufpos
) == ZV
13257 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
13258 /* Former continuation line has disappeared by becoming empty. */
13260 else if (w
->last_modified
< MODIFF
13261 || w
->last_overlay_modified
< OVERLAY_MODIFF
13262 || MINI_WINDOW_P (w
))
13264 /* We have to handle the case of continuation around a
13265 wide-column character (see the comment in indent.c around
13268 For instance, in the following case:
13270 -------- Insert --------
13271 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
13272 J_I_ ==> J_I_ `^^' are cursors.
13276 As we have to redraw the line above, we cannot use this
13280 int line_height_before
= this_line_pixel_height
;
13282 /* Note that start_display will handle the case that the
13283 line starting at tlbufpos is a continuation line. */
13284 start_display (&it
, w
, tlbufpos
);
13286 /* Implementation note: It this still necessary? */
13287 if (it
.current_x
!= this_line_start_x
)
13290 TRACE ((stderr
, "trying display optimization 1\n"));
13291 w
->cursor
.vpos
= -1;
13292 overlay_arrow_seen
= 0;
13293 it
.vpos
= this_line_vpos
;
13294 it
.current_y
= this_line_y
;
13295 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
13296 display_line (&it
);
13298 /* If line contains point, is not continued,
13299 and ends at same distance from eob as before, we win. */
13300 if (w
->cursor
.vpos
>= 0
13301 /* Line is not continued, otherwise this_line_start_pos
13302 would have been set to 0 in display_line. */
13303 && CHARPOS (this_line_start_pos
)
13304 /* Line ends as before. */
13305 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
13306 /* Line has same height as before. Otherwise other lines
13307 would have to be shifted up or down. */
13308 && this_line_pixel_height
== line_height_before
)
13310 /* If this is not the window's last line, we must adjust
13311 the charstarts of the lines below. */
13312 if (it
.current_y
< it
.last_visible_y
)
13314 struct glyph_row
*row
13315 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
13316 ptrdiff_t delta
, delta_bytes
;
13318 /* We used to distinguish between two cases here,
13319 conditioned by Z - CHARPOS (tlendpos) == ZV, for
13320 when the line ends in a newline or the end of the
13321 buffer's accessible portion. But both cases did
13322 the same, so they were collapsed. */
13324 - CHARPOS (tlendpos
)
13325 - MATRIX_ROW_START_CHARPOS (row
));
13326 delta_bytes
= (Z_BYTE
13327 - BYTEPOS (tlendpos
)
13328 - MATRIX_ROW_START_BYTEPOS (row
));
13330 increment_matrix_positions (w
->current_matrix
,
13331 this_line_vpos
+ 1,
13332 w
->current_matrix
->nrows
,
13333 delta
, delta_bytes
);
13336 /* If this row displays text now but previously didn't,
13337 or vice versa, w->window_end_vpos may have to be
13339 if ((it
.glyph_row
- 1)->displays_text_p
)
13341 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
13342 wset_window_end_vpos (w
, make_number (this_line_vpos
));
13344 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
13345 && this_line_vpos
> 0)
13346 wset_window_end_vpos (w
, make_number (this_line_vpos
- 1));
13347 wset_window_end_valid (w
, Qnil
);
13349 /* Update hint: No need to try to scroll in update_window. */
13350 w
->desired_matrix
->no_scrolling_p
= 1;
13353 *w
->desired_matrix
->method
= 0;
13354 debug_method_add (w
, "optimization 1");
13356 #ifdef HAVE_WINDOW_SYSTEM
13357 update_window_fringes (w
, 0);
13364 else if (/* Cursor position hasn't changed. */
13365 PT
== w
->last_point
13366 /* Make sure the cursor was last displayed
13367 in this window. Otherwise we have to reposition it. */
13368 && 0 <= w
->cursor
.vpos
13369 && WINDOW_TOTAL_LINES (w
) > w
->cursor
.vpos
)
13373 do_pending_window_change (1);
13374 /* If selected_window changed, redisplay again. */
13375 if (WINDOWP (selected_window
)
13376 && (w
= XWINDOW (selected_window
)) != sw
)
13379 /* We used to always goto end_of_redisplay here, but this
13380 isn't enough if we have a blinking cursor. */
13381 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
13382 goto end_of_redisplay
;
13386 /* If highlighting the region, or if the cursor is in the echo area,
13387 then we can't just move the cursor. */
13388 else if (! (!NILP (Vtransient_mark_mode
)
13389 && !NILP (BVAR (current_buffer
, mark_active
)))
13390 && (EQ (selected_window
,
13391 BVAR (current_buffer
, last_selected_window
))
13392 || highlight_nonselected_windows
)
13393 && NILP (w
->region_showing
)
13394 && NILP (Vshow_trailing_whitespace
)
13395 && !cursor_in_echo_area
)
13398 struct glyph_row
*row
;
13400 /* Skip from tlbufpos to PT and see where it is. Note that
13401 PT may be in invisible text. If so, we will end at the
13402 next visible position. */
13403 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
13404 NULL
, DEFAULT_FACE_ID
);
13405 it
.current_x
= this_line_start_x
;
13406 it
.current_y
= this_line_y
;
13407 it
.vpos
= this_line_vpos
;
13409 /* The call to move_it_to stops in front of PT, but
13410 moves over before-strings. */
13411 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
13413 if (it
.vpos
== this_line_vpos
13414 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
13417 eassert (this_line_vpos
== it
.vpos
);
13418 eassert (this_line_y
== it
.current_y
);
13419 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
13421 *w
->desired_matrix
->method
= 0;
13422 debug_method_add (w
, "optimization 3");
13431 /* Text changed drastically or point moved off of line. */
13432 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
13435 CHARPOS (this_line_start_pos
) = 0;
13436 consider_all_windows_p
|= buffer_shared
> 1;
13437 ++clear_face_cache_count
;
13438 #ifdef HAVE_WINDOW_SYSTEM
13439 ++clear_image_cache_count
;
13442 /* Build desired matrices, and update the display. If
13443 consider_all_windows_p is non-zero, do it for all windows on all
13444 frames. Otherwise do it for selected_window, only. */
13446 if (consider_all_windows_p
)
13448 Lisp_Object tail
, frame
;
13450 FOR_EACH_FRAME (tail
, frame
)
13451 XFRAME (frame
)->updated_p
= 0;
13453 /* Recompute # windows showing selected buffer. This will be
13454 incremented each time such a window is displayed. */
13457 FOR_EACH_FRAME (tail
, frame
)
13459 struct frame
*f
= XFRAME (frame
);
13461 /* We don't have to do anything for unselected terminal
13463 if ((FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
13464 && !EQ (FRAME_TTY (f
)->top_frame
, frame
))
13467 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
13469 if (! EQ (frame
, selected_frame
))
13470 /* Select the frame, for the sake of frame-local
13472 select_frame_for_redisplay (frame
);
13474 /* Mark all the scroll bars to be removed; we'll redeem
13475 the ones we want when we redisplay their windows. */
13476 if (FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
13477 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
13479 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13480 redisplay_windows (FRAME_ROOT_WINDOW (f
));
13482 /* The X error handler may have deleted that frame. */
13483 if (!FRAME_LIVE_P (f
))
13486 /* Any scroll bars which redisplay_windows should have
13487 nuked should now go away. */
13488 if (FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
13489 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
13491 /* If fonts changed, display again. */
13492 /* ??? rms: I suspect it is a mistake to jump all the way
13493 back to retry here. It should just retry this frame. */
13494 if (fonts_changed_p
)
13497 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13499 /* See if we have to hscroll. */
13500 if (!f
->already_hscrolled_p
)
13502 f
->already_hscrolled_p
= 1;
13503 if (hscroll_windows (f
->root_window
))
13507 /* Prevent various kinds of signals during display
13508 update. stdio is not robust about handling
13509 signals, which can cause an apparent I/O
13511 if (interrupt_input
)
13512 unrequest_sigio ();
13515 /* Update the display. */
13516 set_window_update_flags (XWINDOW (f
->root_window
), 1);
13517 pending
|= update_frame (f
, 0, 0);
13523 if (!EQ (old_frame
, selected_frame
)
13524 && FRAME_LIVE_P (XFRAME (old_frame
)))
13525 /* We played a bit fast-and-loose above and allowed selected_frame
13526 and selected_window to be temporarily out-of-sync but let's make
13527 sure this stays contained. */
13528 select_frame_for_redisplay (old_frame
);
13529 eassert (EQ (XFRAME (selected_frame
)->selected_window
,
13534 /* Do the mark_window_display_accurate after all windows have
13535 been redisplayed because this call resets flags in buffers
13536 which are needed for proper redisplay. */
13537 FOR_EACH_FRAME (tail
, frame
)
13539 struct frame
*f
= XFRAME (frame
);
13542 mark_window_display_accurate (f
->root_window
, 1);
13543 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
13544 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
13549 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13551 Lisp_Object mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13552 struct frame
*mini_frame
;
13554 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
13555 /* Use list_of_error, not Qerror, so that
13556 we catch only errors and don't run the debugger. */
13557 internal_condition_case_1 (redisplay_window_1
, selected_window
,
13559 redisplay_window_error
);
13560 if (update_miniwindow_p
)
13561 internal_condition_case_1 (redisplay_window_1
, mini_window
,
13563 redisplay_window_error
);
13565 /* Compare desired and current matrices, perform output. */
13568 /* If fonts changed, display again. */
13569 if (fonts_changed_p
)
13572 /* Prevent various kinds of signals during display update.
13573 stdio is not robust about handling signals,
13574 which can cause an apparent I/O error. */
13575 if (interrupt_input
)
13576 unrequest_sigio ();
13579 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13581 if (hscroll_windows (selected_window
))
13584 XWINDOW (selected_window
)->must_be_updated_p
= 1;
13585 pending
= update_frame (sf
, 0, 0);
13588 /* We may have called echo_area_display at the top of this
13589 function. If the echo area is on another frame, that may
13590 have put text on a frame other than the selected one, so the
13591 above call to update_frame would not have caught it. Catch
13593 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13594 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
13596 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
13598 XWINDOW (mini_window
)->must_be_updated_p
= 1;
13599 pending
|= update_frame (mini_frame
, 0, 0);
13600 if (!pending
&& hscroll_windows (mini_window
))
13605 /* If display was paused because of pending input, make sure we do a
13606 thorough update the next time. */
13609 /* Prevent the optimization at the beginning of
13610 redisplay_internal that tries a single-line update of the
13611 line containing the cursor in the selected window. */
13612 CHARPOS (this_line_start_pos
) = 0;
13614 /* Let the overlay arrow be updated the next time. */
13615 update_overlay_arrows (0);
13617 /* If we pause after scrolling, some rows in the current
13618 matrices of some windows are not valid. */
13619 if (!WINDOW_FULL_WIDTH_P (w
)
13620 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
13621 update_mode_lines
= 1;
13625 if (!consider_all_windows_p
)
13627 /* This has already been done above if
13628 consider_all_windows_p is set. */
13629 mark_window_display_accurate_1 (w
, 1);
13631 /* Say overlay arrows are up to date. */
13632 update_overlay_arrows (1);
13634 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
13635 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
13638 update_mode_lines
= 0;
13639 windows_or_buffers_changed
= 0;
13640 cursor_type_changed
= 0;
13643 /* Start SIGIO interrupts coming again. Having them off during the
13644 code above makes it less likely one will discard output, but not
13645 impossible, since there might be stuff in the system buffer here.
13646 But it is much hairier to try to do anything about that. */
13647 if (interrupt_input
)
13651 /* If a frame has become visible which was not before, redisplay
13652 again, so that we display it. Expose events for such a frame
13653 (which it gets when becoming visible) don't call the parts of
13654 redisplay constructing glyphs, so simply exposing a frame won't
13655 display anything in this case. So, we have to display these
13656 frames here explicitly. */
13659 Lisp_Object tail
, frame
;
13662 FOR_EACH_FRAME (tail
, frame
)
13664 int this_is_visible
= 0;
13666 if (XFRAME (frame
)->visible
)
13667 this_is_visible
= 1;
13668 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
13669 if (XFRAME (frame
)->visible
)
13670 this_is_visible
= 1;
13672 if (this_is_visible
)
13676 if (new_count
!= number_of_visible_frames
)
13677 windows_or_buffers_changed
++;
13680 /* Change frame size now if a change is pending. */
13681 do_pending_window_change (1);
13683 /* If we just did a pending size change, or have additional
13684 visible frames, or selected_window changed, redisplay again. */
13685 if ((windows_or_buffers_changed
&& !pending
)
13686 || (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
))
13689 /* Clear the face and image caches.
13691 We used to do this only if consider_all_windows_p. But the cache
13692 needs to be cleared if a timer creates images in the current
13693 buffer (e.g. the test case in Bug#6230). */
13695 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
13697 clear_face_cache (0);
13698 clear_face_cache_count
= 0;
13701 #ifdef HAVE_WINDOW_SYSTEM
13702 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
13704 clear_image_caches (Qnil
);
13705 clear_image_cache_count
= 0;
13707 #endif /* HAVE_WINDOW_SYSTEM */
13710 backtrace_list
= backtrace
.next
;
13711 unbind_to (count
, Qnil
);
13716 /* Redisplay, but leave alone any recent echo area message unless
13717 another message has been requested in its place.
13719 This is useful in situations where you need to redisplay but no
13720 user action has occurred, making it inappropriate for the message
13721 area to be cleared. See tracking_off and
13722 wait_reading_process_output for examples of these situations.
13724 FROM_WHERE is an integer saying from where this function was
13725 called. This is useful for debugging. */
13728 redisplay_preserve_echo_area (int from_where
)
13730 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
13732 if (!NILP (echo_area_buffer
[1]))
13734 /* We have a previously displayed message, but no current
13735 message. Redisplay the previous message. */
13736 display_last_displayed_message_p
= 1;
13737 redisplay_internal ();
13738 display_last_displayed_message_p
= 0;
13741 redisplay_internal ();
13743 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
13744 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
13745 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL
);
13749 /* Function registered with record_unwind_protect in redisplay_internal.
13750 Clear redisplaying_p. Also, select the previously
13751 selected frame, unless it has been deleted (by an X connection
13752 failure during redisplay, for example). */
13755 unwind_redisplay (Lisp_Object old_frame
)
13757 redisplaying_p
= 0;
13758 if (! EQ (old_frame
, selected_frame
)
13759 && FRAME_LIVE_P (XFRAME (old_frame
)))
13760 select_frame_for_redisplay (old_frame
);
13765 /* Mark the display of window W as accurate or inaccurate. If
13766 ACCURATE_P is non-zero mark display of W as accurate. If
13767 ACCURATE_P is zero, arrange for W to be redisplayed the next time
13768 redisplay_internal is called. */
13771 mark_window_display_accurate_1 (struct window
*w
, int accurate_p
)
13773 if (BUFFERP (w
->buffer
))
13775 struct buffer
*b
= XBUFFER (w
->buffer
);
13777 w
->last_modified
= accurate_p
? BUF_MODIFF(b
) : 0;
13778 w
->last_overlay_modified
= accurate_p
? BUF_OVERLAY_MODIFF(b
) : 0;
13780 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
);
13784 b
->clip_changed
= 0;
13785 b
->prevent_redisplay_optimizations_p
= 0;
13787 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
13788 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
13789 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
13790 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
13792 w
->current_matrix
->buffer
= b
;
13793 w
->current_matrix
->begv
= BUF_BEGV (b
);
13794 w
->current_matrix
->zv
= BUF_ZV (b
);
13796 w
->last_cursor
= w
->cursor
;
13797 w
->last_cursor_off_p
= w
->cursor_off_p
;
13799 if (w
== XWINDOW (selected_window
))
13800 w
->last_point
= BUF_PT (b
);
13802 w
->last_point
= XMARKER (w
->pointm
)->charpos
;
13808 wset_window_end_valid (w
, w
->buffer
);
13809 w
->update_mode_line
= 0;
13814 /* Mark the display of windows in the window tree rooted at WINDOW as
13815 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
13816 windows as accurate. If ACCURATE_P is zero, arrange for windows to
13817 be redisplayed the next time redisplay_internal is called. */
13820 mark_window_display_accurate (Lisp_Object window
, int accurate_p
)
13824 for (; !NILP (window
); window
= w
->next
)
13826 w
= XWINDOW (window
);
13827 mark_window_display_accurate_1 (w
, accurate_p
);
13829 if (!NILP (w
->vchild
))
13830 mark_window_display_accurate (w
->vchild
, accurate_p
);
13831 if (!NILP (w
->hchild
))
13832 mark_window_display_accurate (w
->hchild
, accurate_p
);
13837 update_overlay_arrows (1);
13841 /* Force a thorough redisplay the next time by setting
13842 last_arrow_position and last_arrow_string to t, which is
13843 unequal to any useful value of Voverlay_arrow_... */
13844 update_overlay_arrows (-1);
13849 /* Return value in display table DP (Lisp_Char_Table *) for character
13850 C. Since a display table doesn't have any parent, we don't have to
13851 follow parent. Do not call this function directly but use the
13852 macro DISP_CHAR_VECTOR. */
13855 disp_char_vector (struct Lisp_Char_Table
*dp
, int c
)
13859 if (ASCII_CHAR_P (c
))
13862 if (SUB_CHAR_TABLE_P (val
))
13863 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
13869 XSETCHAR_TABLE (table
, dp
);
13870 val
= char_table_ref (table
, c
);
13879 /***********************************************************************
13881 ***********************************************************************/
13883 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
13886 redisplay_windows (Lisp_Object window
)
13888 while (!NILP (window
))
13890 struct window
*w
= XWINDOW (window
);
13892 if (!NILP (w
->hchild
))
13893 redisplay_windows (w
->hchild
);
13894 else if (!NILP (w
->vchild
))
13895 redisplay_windows (w
->vchild
);
13896 else if (!NILP (w
->buffer
))
13898 displayed_buffer
= XBUFFER (w
->buffer
);
13899 /* Use list_of_error, not Qerror, so that
13900 we catch only errors and don't run the debugger. */
13901 internal_condition_case_1 (redisplay_window_0
, window
,
13903 redisplay_window_error
);
13911 redisplay_window_error (Lisp_Object ignore
)
13913 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
13918 redisplay_window_0 (Lisp_Object window
)
13920 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13921 redisplay_window (window
, 0);
13926 redisplay_window_1 (Lisp_Object window
)
13928 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13929 redisplay_window (window
, 1);
13934 /* Set cursor position of W. PT is assumed to be displayed in ROW.
13935 DELTA and DELTA_BYTES are the numbers of characters and bytes by
13936 which positions recorded in ROW differ from current buffer
13939 Return 0 if cursor is not on this row, 1 otherwise. */
13942 set_cursor_from_row (struct window
*w
, struct glyph_row
*row
,
13943 struct glyph_matrix
*matrix
,
13944 ptrdiff_t delta
, ptrdiff_t delta_bytes
,
13947 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
13948 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
13949 struct glyph
*cursor
= NULL
;
13950 /* The last known character position in row. */
13951 ptrdiff_t last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13953 ptrdiff_t pt_old
= PT
- delta
;
13954 ptrdiff_t pos_before
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13955 ptrdiff_t pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
13956 struct glyph
*glyph_before
= glyph
- 1, *glyph_after
= end
;
13957 /* A glyph beyond the edge of TEXT_AREA which we should never
13959 struct glyph
*glyphs_end
= end
;
13960 /* Non-zero means we've found a match for cursor position, but that
13961 glyph has the avoid_cursor_p flag set. */
13962 int match_with_avoid_cursor
= 0;
13963 /* Non-zero means we've seen at least one glyph that came from a
13965 int string_seen
= 0;
13966 /* Largest and smallest buffer positions seen so far during scan of
13968 ptrdiff_t bpos_max
= pos_before
;
13969 ptrdiff_t bpos_min
= pos_after
;
13970 /* Last buffer position covered by an overlay string with an integer
13971 `cursor' property. */
13972 ptrdiff_t bpos_covered
= 0;
13973 /* Non-zero means the display string on which to display the cursor
13974 comes from a text property, not from an overlay. */
13975 int string_from_text_prop
= 0;
13977 /* Don't even try doing anything if called for a mode-line or
13978 header-line row, since the rest of the code isn't prepared to
13979 deal with such calamities. */
13980 eassert (!row
->mode_line_p
);
13981 if (row
->mode_line_p
)
13984 /* Skip over glyphs not having an object at the start and the end of
13985 the row. These are special glyphs like truncation marks on
13986 terminal frames. */
13987 if (row
->displays_text_p
)
13989 if (!row
->reversed_p
)
13992 && INTEGERP (glyph
->object
)
13993 && glyph
->charpos
< 0)
13995 x
+= glyph
->pixel_width
;
13999 && INTEGERP ((end
- 1)->object
)
14000 /* CHARPOS is zero for blanks and stretch glyphs
14001 inserted by extend_face_to_end_of_line. */
14002 && (end
- 1)->charpos
<= 0)
14004 glyph_before
= glyph
- 1;
14011 /* If the glyph row is reversed, we need to process it from back
14012 to front, so swap the edge pointers. */
14013 glyphs_end
= end
= glyph
- 1;
14014 glyph
+= row
->used
[TEXT_AREA
] - 1;
14016 while (glyph
> end
+ 1
14017 && INTEGERP (glyph
->object
)
14018 && glyph
->charpos
< 0)
14021 x
-= glyph
->pixel_width
;
14023 if (INTEGERP (glyph
->object
) && glyph
->charpos
< 0)
14025 /* By default, in reversed rows we put the cursor on the
14026 rightmost (first in the reading order) glyph. */
14027 for (g
= end
+ 1; g
< glyph
; g
++)
14028 x
+= g
->pixel_width
;
14030 && INTEGERP ((end
+ 1)->object
)
14031 && (end
+ 1)->charpos
<= 0)
14033 glyph_before
= glyph
+ 1;
14037 else if (row
->reversed_p
)
14039 /* In R2L rows that don't display text, put the cursor on the
14040 rightmost glyph. Case in point: an empty last line that is
14041 part of an R2L paragraph. */
14043 /* Avoid placing the cursor on the last glyph of the row, where
14044 on terminal frames we hold the vertical border between
14045 adjacent windows. */
14046 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w
))
14047 && !WINDOW_RIGHTMOST_P (w
)
14048 && cursor
== row
->glyphs
[LAST_AREA
] - 1)
14050 x
= -1; /* will be computed below, at label compute_x */
14053 /* Step 1: Try to find the glyph whose character position
14054 corresponds to point. If that's not possible, find 2 glyphs
14055 whose character positions are the closest to point, one before
14056 point, the other after it. */
14057 if (!row
->reversed_p
)
14058 while (/* not marched to end of glyph row */
14060 /* glyph was not inserted by redisplay for internal purposes */
14061 && !INTEGERP (glyph
->object
))
14063 if (BUFFERP (glyph
->object
))
14065 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14067 if (glyph
->charpos
> bpos_max
)
14068 bpos_max
= glyph
->charpos
;
14069 if (glyph
->charpos
< bpos_min
)
14070 bpos_min
= glyph
->charpos
;
14071 if (!glyph
->avoid_cursor_p
)
14073 /* If we hit point, we've found the glyph on which to
14074 display the cursor. */
14077 match_with_avoid_cursor
= 0;
14080 /* See if we've found a better approximation to
14081 POS_BEFORE or to POS_AFTER. */
14082 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14084 pos_before
= glyph
->charpos
;
14085 glyph_before
= glyph
;
14087 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14089 pos_after
= glyph
->charpos
;
14090 glyph_after
= glyph
;
14093 else if (dpos
== 0)
14094 match_with_avoid_cursor
= 1;
14096 else if (STRINGP (glyph
->object
))
14098 Lisp_Object chprop
;
14099 ptrdiff_t glyph_pos
= glyph
->charpos
;
14101 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14103 if (!NILP (chprop
))
14105 /* If the string came from a `display' text property,
14106 look up the buffer position of that property and
14107 use that position to update bpos_max, as if we
14108 actually saw such a position in one of the row's
14109 glyphs. This helps with supporting integer values
14110 of `cursor' property on the display string in
14111 situations where most or all of the row's buffer
14112 text is completely covered by display properties,
14113 so that no glyph with valid buffer positions is
14114 ever seen in the row. */
14115 ptrdiff_t prop_pos
=
14116 string_buffer_position_lim (glyph
->object
, pos_before
,
14119 if (prop_pos
>= pos_before
)
14120 bpos_max
= prop_pos
- 1;
14122 if (INTEGERP (chprop
))
14124 bpos_covered
= bpos_max
+ XINT (chprop
);
14125 /* If the `cursor' property covers buffer positions up
14126 to and including point, we should display cursor on
14127 this glyph. Note that, if a `cursor' property on one
14128 of the string's characters has an integer value, we
14129 will break out of the loop below _before_ we get to
14130 the position match above. IOW, integer values of
14131 the `cursor' property override the "exact match for
14132 point" strategy of positioning the cursor. */
14133 /* Implementation note: bpos_max == pt_old when, e.g.,
14134 we are in an empty line, where bpos_max is set to
14135 MATRIX_ROW_START_CHARPOS, see above. */
14136 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14145 x
+= glyph
->pixel_width
;
14148 else if (glyph
> end
) /* row is reversed */
14149 while (!INTEGERP (glyph
->object
))
14151 if (BUFFERP (glyph
->object
))
14153 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14155 if (glyph
->charpos
> bpos_max
)
14156 bpos_max
= glyph
->charpos
;
14157 if (glyph
->charpos
< bpos_min
)
14158 bpos_min
= glyph
->charpos
;
14159 if (!glyph
->avoid_cursor_p
)
14163 match_with_avoid_cursor
= 0;
14166 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14168 pos_before
= glyph
->charpos
;
14169 glyph_before
= glyph
;
14171 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14173 pos_after
= glyph
->charpos
;
14174 glyph_after
= glyph
;
14177 else if (dpos
== 0)
14178 match_with_avoid_cursor
= 1;
14180 else if (STRINGP (glyph
->object
))
14182 Lisp_Object chprop
;
14183 ptrdiff_t glyph_pos
= glyph
->charpos
;
14185 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14187 if (!NILP (chprop
))
14189 ptrdiff_t prop_pos
=
14190 string_buffer_position_lim (glyph
->object
, pos_before
,
14193 if (prop_pos
>= pos_before
)
14194 bpos_max
= prop_pos
- 1;
14196 if (INTEGERP (chprop
))
14198 bpos_covered
= bpos_max
+ XINT (chprop
);
14199 /* If the `cursor' property covers buffer positions up
14200 to and including point, we should display cursor on
14202 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14211 if (glyph
== glyphs_end
) /* don't dereference outside TEXT_AREA */
14213 x
--; /* can't use any pixel_width */
14216 x
-= glyph
->pixel_width
;
14219 /* Step 2: If we didn't find an exact match for point, we need to
14220 look for a proper place to put the cursor among glyphs between
14221 GLYPH_BEFORE and GLYPH_AFTER. */
14222 if (!((row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14223 && BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14224 && bpos_covered
< pt_old
)
14226 /* An empty line has a single glyph whose OBJECT is zero and
14227 whose CHARPOS is the position of a newline on that line.
14228 Note that on a TTY, there are more glyphs after that, which
14229 were produced by extend_face_to_end_of_line, but their
14230 CHARPOS is zero or negative. */
14232 (row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14233 && INTEGERP (glyph
->object
) && glyph
->charpos
> 0;
14235 if (row
->ends_in_ellipsis_p
&& pos_after
== last_pos
)
14237 ptrdiff_t ellipsis_pos
;
14239 /* Scan back over the ellipsis glyphs. */
14240 if (!row
->reversed_p
)
14242 ellipsis_pos
= (glyph
- 1)->charpos
;
14243 while (glyph
> row
->glyphs
[TEXT_AREA
]
14244 && (glyph
- 1)->charpos
== ellipsis_pos
)
14245 glyph
--, x
-= glyph
->pixel_width
;
14246 /* That loop always goes one position too far, including
14247 the glyph before the ellipsis. So scan forward over
14249 x
+= glyph
->pixel_width
;
14252 else /* row is reversed */
14254 ellipsis_pos
= (glyph
+ 1)->charpos
;
14255 while (glyph
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14256 && (glyph
+ 1)->charpos
== ellipsis_pos
)
14257 glyph
++, x
+= glyph
->pixel_width
;
14258 x
-= glyph
->pixel_width
;
14262 else if (match_with_avoid_cursor
)
14264 cursor
= glyph_after
;
14267 else if (string_seen
)
14269 int incr
= row
->reversed_p
? -1 : +1;
14271 /* Need to find the glyph that came out of a string which is
14272 present at point. That glyph is somewhere between
14273 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
14274 positioned between POS_BEFORE and POS_AFTER in the
14276 struct glyph
*start
, *stop
;
14277 ptrdiff_t pos
= pos_before
;
14281 /* If the row ends in a newline from a display string,
14282 reordering could have moved the glyphs belonging to the
14283 string out of the [GLYPH_BEFORE..GLYPH_AFTER] range. So
14284 in this case we extend the search to the last glyph in
14285 the row that was not inserted by redisplay. */
14286 if (row
->ends_in_newline_from_string_p
)
14289 pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
14292 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
14293 correspond to POS_BEFORE and POS_AFTER, respectively. We
14294 need START and STOP in the order that corresponds to the
14295 row's direction as given by its reversed_p flag. If the
14296 directionality of characters between POS_BEFORE and
14297 POS_AFTER is the opposite of the row's base direction,
14298 these characters will have been reordered for display,
14299 and we need to reverse START and STOP. */
14300 if (!row
->reversed_p
)
14302 start
= min (glyph_before
, glyph_after
);
14303 stop
= max (glyph_before
, glyph_after
);
14307 start
= max (glyph_before
, glyph_after
);
14308 stop
= min (glyph_before
, glyph_after
);
14310 for (glyph
= start
+ incr
;
14311 row
->reversed_p
? glyph
> stop
: glyph
< stop
; )
14314 /* Any glyphs that come from the buffer are here because
14315 of bidi reordering. Skip them, and only pay
14316 attention to glyphs that came from some string. */
14317 if (STRINGP (glyph
->object
))
14321 /* If the display property covers the newline, we
14322 need to search for it one position farther. */
14323 ptrdiff_t lim
= pos_after
14324 + (pos_after
== MATRIX_ROW_END_CHARPOS (row
) + delta
);
14326 string_from_text_prop
= 0;
14327 str
= glyph
->object
;
14328 tem
= string_buffer_position_lim (str
, pos
, lim
, 0);
14329 if (tem
== 0 /* from overlay */
14332 /* If the string from which this glyph came is
14333 found in the buffer at point, or at position
14334 that is closer to point than pos_after, then
14335 we've found the glyph we've been looking for.
14336 If it comes from an overlay (tem == 0), and
14337 it has the `cursor' property on one of its
14338 glyphs, record that glyph as a candidate for
14339 displaying the cursor. (As in the
14340 unidirectional version, we will display the
14341 cursor on the last candidate we find.) */
14344 || (tem
- pt_old
> 0 && tem
< pos_after
))
14346 /* The glyphs from this string could have
14347 been reordered. Find the one with the
14348 smallest string position. Or there could
14349 be a character in the string with the
14350 `cursor' property, which means display
14351 cursor on that character's glyph. */
14352 ptrdiff_t strpos
= glyph
->charpos
;
14357 string_from_text_prop
= 1;
14360 (row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14361 && EQ (glyph
->object
, str
);
14365 ptrdiff_t gpos
= glyph
->charpos
;
14367 cprop
= Fget_char_property (make_number (gpos
),
14375 if (tem
&& glyph
->charpos
< strpos
)
14377 strpos
= glyph
->charpos
;
14383 || (tem
- pt_old
> 0 && tem
< pos_after
))
14387 pos
= tem
+ 1; /* don't find previous instances */
14389 /* This string is not what we want; skip all of the
14390 glyphs that came from it. */
14391 while ((row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14392 && EQ (glyph
->object
, str
))
14399 /* If we reached the end of the line, and END was from a string,
14400 the cursor is not on this line. */
14402 && (row
->reversed_p
? glyph
<= end
: glyph
>= end
)
14403 && (row
->reversed_p
? end
> glyphs_end
: end
< glyphs_end
)
14404 && STRINGP (end
->object
)
14405 && row
->continued_p
)
14408 /* A truncated row may not include PT among its character positions.
14409 Setting the cursor inside the scroll margin will trigger
14410 recalculation of hscroll in hscroll_window_tree. But if a
14411 display string covers point, defer to the string-handling
14412 code below to figure this out. */
14413 else if (row
->truncated_on_left_p
&& pt_old
< bpos_min
)
14415 cursor
= glyph_before
;
14418 else if ((row
->truncated_on_right_p
&& pt_old
> bpos_max
)
14419 /* Zero-width characters produce no glyphs. */
14421 && (row
->reversed_p
14422 ? glyph_after
> glyphs_end
14423 : glyph_after
< glyphs_end
)))
14425 cursor
= glyph_after
;
14431 if (cursor
!= NULL
)
14433 else if (glyph
== glyphs_end
14434 && pos_before
== pos_after
14435 && STRINGP ((row
->reversed_p
14436 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14437 : row
->glyphs
[TEXT_AREA
])->object
))
14439 /* If all the glyphs of this row came from strings, put the
14440 cursor on the first glyph of the row. This avoids having the
14441 cursor outside of the text area in this very rare and hard
14445 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14446 : row
->glyphs
[TEXT_AREA
];
14452 /* Need to compute x that corresponds to GLYPH. */
14453 for (g
= row
->glyphs
[TEXT_AREA
], x
= row
->x
; g
< glyph
; g
++)
14455 if (g
>= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
])
14457 x
+= g
->pixel_width
;
14461 /* ROW could be part of a continued line, which, under bidi
14462 reordering, might have other rows whose start and end charpos
14463 occlude point. Only set w->cursor if we found a better
14464 approximation to the cursor position than we have from previously
14465 examined candidate rows belonging to the same continued line. */
14466 if (/* we already have a candidate row */
14467 w
->cursor
.vpos
>= 0
14468 /* that candidate is not the row we are processing */
14469 && MATRIX_ROW (matrix
, w
->cursor
.vpos
) != row
14470 /* Make sure cursor.vpos specifies a row whose start and end
14471 charpos occlude point, and it is valid candidate for being a
14472 cursor-row. This is because some callers of this function
14473 leave cursor.vpos at the row where the cursor was displayed
14474 during the last redisplay cycle. */
14475 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)) <= pt_old
14476 && pt_old
<= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14477 && cursor_row_p (MATRIX_ROW (matrix
, w
->cursor
.vpos
)))
14480 MATRIX_ROW_GLYPH_START (matrix
, w
->cursor
.vpos
) + w
->cursor
.hpos
;
14482 /* Don't consider glyphs that are outside TEXT_AREA. */
14483 if (!(row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
))
14485 /* Keep the candidate whose buffer position is the closest to
14486 point or has the `cursor' property. */
14487 if (/* previous candidate is a glyph in TEXT_AREA of that row */
14488 w
->cursor
.hpos
>= 0
14489 && w
->cursor
.hpos
< MATRIX_ROW_USED (matrix
, w
->cursor
.vpos
)
14490 && ((BUFFERP (g1
->object
)
14491 && (g1
->charpos
== pt_old
/* an exact match always wins */
14492 || (BUFFERP (glyph
->object
)
14493 && eabs (g1
->charpos
- pt_old
)
14494 < eabs (glyph
->charpos
- pt_old
))))
14495 /* previous candidate is a glyph from a string that has
14496 a non-nil `cursor' property */
14497 || (STRINGP (g1
->object
)
14498 && (!NILP (Fget_char_property (make_number (g1
->charpos
),
14499 Qcursor
, g1
->object
))
14500 /* previous candidate is from the same display
14501 string as this one, and the display string
14502 came from a text property */
14503 || (EQ (g1
->object
, glyph
->object
)
14504 && string_from_text_prop
)
14505 /* this candidate is from newline and its
14506 position is not an exact match */
14507 || (INTEGERP (glyph
->object
)
14508 && glyph
->charpos
!= pt_old
)))))
14510 /* If this candidate gives an exact match, use that. */
14511 if (!((BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14512 /* If this candidate is a glyph created for the
14513 terminating newline of a line, and point is on that
14514 newline, it wins because it's an exact match. */
14515 || (!row
->continued_p
14516 && INTEGERP (glyph
->object
)
14517 && glyph
->charpos
== 0
14518 && pt_old
== MATRIX_ROW_END_CHARPOS (row
) - 1))
14519 /* Otherwise, keep the candidate that comes from a row
14520 spanning less buffer positions. This may win when one or
14521 both candidate positions are on glyphs that came from
14522 display strings, for which we cannot compare buffer
14524 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14525 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14526 < MATRIX_ROW_END_CHARPOS (row
) - MATRIX_ROW_START_CHARPOS (row
))
14529 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
14531 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
14532 w
->cursor
.y
= row
->y
+ dy
;
14534 if (w
== XWINDOW (selected_window
))
14536 if (!row
->continued_p
14537 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
14540 this_line_buffer
= XBUFFER (w
->buffer
);
14542 CHARPOS (this_line_start_pos
)
14543 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
14544 BYTEPOS (this_line_start_pos
)
14545 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
14547 CHARPOS (this_line_end_pos
)
14548 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
14549 BYTEPOS (this_line_end_pos
)
14550 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
14552 this_line_y
= w
->cursor
.y
;
14553 this_line_pixel_height
= row
->height
;
14554 this_line_vpos
= w
->cursor
.vpos
;
14555 this_line_start_x
= row
->x
;
14558 CHARPOS (this_line_start_pos
) = 0;
14565 /* Run window scroll functions, if any, for WINDOW with new window
14566 start STARTP. Sets the window start of WINDOW to that position.
14568 We assume that the window's buffer is really current. */
14570 static struct text_pos
14571 run_window_scroll_functions (Lisp_Object window
, struct text_pos startp
)
14573 struct window
*w
= XWINDOW (window
);
14574 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
14576 if (current_buffer
!= XBUFFER (w
->buffer
))
14579 if (!NILP (Vwindow_scroll_functions
))
14581 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
14582 make_number (CHARPOS (startp
)));
14583 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14584 /* In case the hook functions switch buffers. */
14585 set_buffer_internal (XBUFFER (w
->buffer
));
14592 /* Make sure the line containing the cursor is fully visible.
14593 A value of 1 means there is nothing to be done.
14594 (Either the line is fully visible, or it cannot be made so,
14595 or we cannot tell.)
14597 If FORCE_P is non-zero, return 0 even if partial visible cursor row
14598 is higher than window.
14600 A value of 0 means the caller should do scrolling
14601 as if point had gone off the screen. */
14604 cursor_row_fully_visible_p (struct window
*w
, int force_p
, int current_matrix_p
)
14606 struct glyph_matrix
*matrix
;
14607 struct glyph_row
*row
;
14610 if (!make_cursor_line_fully_visible_p
)
14613 /* It's not always possible to find the cursor, e.g, when a window
14614 is full of overlay strings. Don't do anything in that case. */
14615 if (w
->cursor
.vpos
< 0)
14618 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
14619 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
14621 /* If the cursor row is not partially visible, there's nothing to do. */
14622 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
14625 /* If the row the cursor is in is taller than the window's height,
14626 it's not clear what to do, so do nothing. */
14627 window_height
= window_box_height (w
);
14628 if (row
->height
>= window_height
)
14630 if (!force_p
|| MINI_WINDOW_P (w
)
14631 || w
->vscroll
|| w
->cursor
.vpos
== 0)
14638 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
14639 non-zero means only WINDOW is redisplayed in redisplay_internal.
14640 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
14641 in redisplay_window to bring a partially visible line into view in
14642 the case that only the cursor has moved.
14644 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
14645 last screen line's vertical height extends past the end of the screen.
14649 1 if scrolling succeeded
14651 0 if scrolling didn't find point.
14653 -1 if new fonts have been loaded so that we must interrupt
14654 redisplay, adjust glyph matrices, and try again. */
14660 SCROLLING_NEED_LARGER_MATRICES
14663 /* If scroll-conservatively is more than this, never recenter.
14665 If you change this, don't forget to update the doc string of
14666 `scroll-conservatively' and the Emacs manual. */
14667 #define SCROLL_LIMIT 100
14670 try_scrolling (Lisp_Object window
, int just_this_one_p
,
14671 ptrdiff_t arg_scroll_conservatively
, ptrdiff_t scroll_step
,
14672 int temp_scroll_step
, int last_line_misfit
)
14674 struct window
*w
= XWINDOW (window
);
14675 struct frame
*f
= XFRAME (w
->frame
);
14676 struct text_pos pos
, startp
;
14678 int this_scroll_margin
, scroll_max
, rc
, height
;
14679 int dy
= 0, amount_to_scroll
= 0, scroll_down_p
= 0;
14680 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
14681 Lisp_Object aggressive
;
14682 /* We will never try scrolling more than this number of lines. */
14683 int scroll_limit
= SCROLL_LIMIT
;
14686 debug_method_add (w
, "try_scrolling");
14689 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14691 /* Compute scroll margin height in pixels. We scroll when point is
14692 within this distance from the top or bottom of the window. */
14693 if (scroll_margin
> 0)
14694 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
14695 * FRAME_LINE_HEIGHT (f
);
14697 this_scroll_margin
= 0;
14699 /* Force arg_scroll_conservatively to have a reasonable value, to
14700 avoid scrolling too far away with slow move_it_* functions. Note
14701 that the user can supply scroll-conservatively equal to
14702 `most-positive-fixnum', which can be larger than INT_MAX. */
14703 if (arg_scroll_conservatively
> scroll_limit
)
14705 arg_scroll_conservatively
= scroll_limit
+ 1;
14706 scroll_max
= scroll_limit
* FRAME_LINE_HEIGHT (f
);
14708 else if (scroll_step
|| arg_scroll_conservatively
|| temp_scroll_step
)
14709 /* Compute how much we should try to scroll maximally to bring
14710 point into view. */
14711 scroll_max
= (max (scroll_step
,
14712 max (arg_scroll_conservatively
, temp_scroll_step
))
14713 * FRAME_LINE_HEIGHT (f
));
14714 else if (NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
))
14715 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
)))
14716 /* We're trying to scroll because of aggressive scrolling but no
14717 scroll_step is set. Choose an arbitrary one. */
14718 scroll_max
= 10 * FRAME_LINE_HEIGHT (f
);
14724 /* Decide whether to scroll down. */
14725 if (PT
> CHARPOS (startp
))
14727 int scroll_margin_y
;
14729 /* Compute the pixel ypos of the scroll margin, then move IT to
14730 either that ypos or PT, whichever comes first. */
14731 start_display (&it
, w
, startp
);
14732 scroll_margin_y
= it
.last_visible_y
- this_scroll_margin
14733 - FRAME_LINE_HEIGHT (f
) * extra_scroll_margin_lines
;
14734 move_it_to (&it
, PT
, -1, scroll_margin_y
- 1, -1,
14735 (MOVE_TO_POS
| MOVE_TO_Y
));
14737 if (PT
> CHARPOS (it
.current
.pos
))
14739 int y0
= line_bottom_y (&it
);
14740 /* Compute how many pixels below window bottom to stop searching
14741 for PT. This avoids costly search for PT that is far away if
14742 the user limited scrolling by a small number of lines, but
14743 always finds PT if scroll_conservatively is set to a large
14744 number, such as most-positive-fixnum. */
14745 int slack
= max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
));
14746 int y_to_move
= it
.last_visible_y
+ slack
;
14748 /* Compute the distance from the scroll margin to PT or to
14749 the scroll limit, whichever comes first. This should
14750 include the height of the cursor line, to make that line
14752 move_it_to (&it
, PT
, -1, y_to_move
,
14753 -1, MOVE_TO_POS
| MOVE_TO_Y
);
14754 dy
= line_bottom_y (&it
) - y0
;
14756 if (dy
> scroll_max
)
14757 return SCROLLING_FAILED
;
14766 /* Point is in or below the bottom scroll margin, so move the
14767 window start down. If scrolling conservatively, move it just
14768 enough down to make point visible. If scroll_step is set,
14769 move it down by scroll_step. */
14770 if (arg_scroll_conservatively
)
14772 = min (max (dy
, FRAME_LINE_HEIGHT (f
)),
14773 FRAME_LINE_HEIGHT (f
) * arg_scroll_conservatively
);
14774 else if (scroll_step
|| temp_scroll_step
)
14775 amount_to_scroll
= scroll_max
;
14778 aggressive
= BVAR (current_buffer
, scroll_up_aggressively
);
14779 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
14780 if (NUMBERP (aggressive
))
14782 double float_amount
= XFLOATINT (aggressive
) * height
;
14783 int aggressive_scroll
= float_amount
;
14784 if (aggressive_scroll
== 0 && float_amount
> 0)
14785 aggressive_scroll
= 1;
14786 /* Don't let point enter the scroll margin near top of
14787 the window. This could happen if the value of
14788 scroll_up_aggressively is too large and there are
14789 non-zero margins, because scroll_up_aggressively
14790 means put point that fraction of window height
14791 _from_the_bottom_margin_. */
14792 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
14793 aggressive_scroll
= height
- 2*this_scroll_margin
;
14794 amount_to_scroll
= dy
+ aggressive_scroll
;
14798 if (amount_to_scroll
<= 0)
14799 return SCROLLING_FAILED
;
14801 start_display (&it
, w
, startp
);
14802 if (arg_scroll_conservatively
<= scroll_limit
)
14803 move_it_vertically (&it
, amount_to_scroll
);
14806 /* Extra precision for users who set scroll-conservatively
14807 to a large number: make sure the amount we scroll
14808 the window start is never less than amount_to_scroll,
14809 which was computed as distance from window bottom to
14810 point. This matters when lines at window top and lines
14811 below window bottom have different height. */
14813 void *it1data
= NULL
;
14814 /* We use a temporary it1 because line_bottom_y can modify
14815 its argument, if it moves one line down; see there. */
14818 SAVE_IT (it1
, it
, it1data
);
14819 start_y
= line_bottom_y (&it1
);
14821 RESTORE_IT (&it
, &it
, it1data
);
14822 move_it_by_lines (&it
, 1);
14823 SAVE_IT (it1
, it
, it1data
);
14824 } while (line_bottom_y (&it1
) - start_y
< amount_to_scroll
);
14827 /* If STARTP is unchanged, move it down another screen line. */
14828 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
14829 move_it_by_lines (&it
, 1);
14830 startp
= it
.current
.pos
;
14834 struct text_pos scroll_margin_pos
= startp
;
14836 /* See if point is inside the scroll margin at the top of the
14838 if (this_scroll_margin
)
14840 start_display (&it
, w
, startp
);
14841 move_it_vertically (&it
, this_scroll_margin
);
14842 scroll_margin_pos
= it
.current
.pos
;
14845 if (PT
< CHARPOS (scroll_margin_pos
))
14847 /* Point is in the scroll margin at the top of the window or
14848 above what is displayed in the window. */
14851 /* Compute the vertical distance from PT to the scroll
14852 margin position. Move as far as scroll_max allows, or
14853 one screenful, or 10 screen lines, whichever is largest.
14854 Give up if distance is greater than scroll_max or if we
14855 didn't reach the scroll margin position. */
14856 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
14857 start_display (&it
, w
, pos
);
14859 y_to_move
= max (it
.last_visible_y
,
14860 max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
)));
14861 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
14863 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
14864 dy
= it
.current_y
- y0
;
14865 if (dy
> scroll_max
14866 || IT_CHARPOS (it
) < CHARPOS (scroll_margin_pos
))
14867 return SCROLLING_FAILED
;
14869 /* Compute new window start. */
14870 start_display (&it
, w
, startp
);
14872 if (arg_scroll_conservatively
)
14873 amount_to_scroll
= max (dy
, FRAME_LINE_HEIGHT (f
) *
14874 max (scroll_step
, temp_scroll_step
));
14875 else if (scroll_step
|| temp_scroll_step
)
14876 amount_to_scroll
= scroll_max
;
14879 aggressive
= BVAR (current_buffer
, scroll_down_aggressively
);
14880 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
14881 if (NUMBERP (aggressive
))
14883 double float_amount
= XFLOATINT (aggressive
) * height
;
14884 int aggressive_scroll
= float_amount
;
14885 if (aggressive_scroll
== 0 && float_amount
> 0)
14886 aggressive_scroll
= 1;
14887 /* Don't let point enter the scroll margin near
14888 bottom of the window, if the value of
14889 scroll_down_aggressively happens to be too
14891 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
14892 aggressive_scroll
= height
- 2*this_scroll_margin
;
14893 amount_to_scroll
= dy
+ aggressive_scroll
;
14897 if (amount_to_scroll
<= 0)
14898 return SCROLLING_FAILED
;
14900 move_it_vertically_backward (&it
, amount_to_scroll
);
14901 startp
= it
.current
.pos
;
14905 /* Run window scroll functions. */
14906 startp
= run_window_scroll_functions (window
, startp
);
14908 /* Display the window. Give up if new fonts are loaded, or if point
14910 if (!try_window (window
, startp
, 0))
14911 rc
= SCROLLING_NEED_LARGER_MATRICES
;
14912 else if (w
->cursor
.vpos
< 0)
14914 clear_glyph_matrix (w
->desired_matrix
);
14915 rc
= SCROLLING_FAILED
;
14919 /* Maybe forget recorded base line for line number display. */
14920 if (!just_this_one_p
14921 || current_buffer
->clip_changed
14922 || BEG_UNCHANGED
< CHARPOS (startp
))
14923 wset_base_line_number (w
, Qnil
);
14925 /* If cursor ends up on a partially visible line,
14926 treat that as being off the bottom of the screen. */
14927 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0)
14928 /* It's possible that the cursor is on the first line of the
14929 buffer, which is partially obscured due to a vscroll
14930 (Bug#7537). In that case, avoid looping forever . */
14931 && extra_scroll_margin_lines
< w
->desired_matrix
->nrows
- 1)
14933 clear_glyph_matrix (w
->desired_matrix
);
14934 ++extra_scroll_margin_lines
;
14937 rc
= SCROLLING_SUCCESS
;
14944 /* Compute a suitable window start for window W if display of W starts
14945 on a continuation line. Value is non-zero if a new window start
14948 The new window start will be computed, based on W's width, starting
14949 from the start of the continued line. It is the start of the
14950 screen line with the minimum distance from the old start W->start. */
14953 compute_window_start_on_continuation_line (struct window
*w
)
14955 struct text_pos pos
, start_pos
;
14956 int window_start_changed_p
= 0;
14958 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
14960 /* If window start is on a continuation line... Window start may be
14961 < BEGV in case there's invisible text at the start of the
14962 buffer (M-x rmail, for example). */
14963 if (CHARPOS (start_pos
) > BEGV
14964 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
14967 struct glyph_row
*row
;
14969 /* Handle the case that the window start is out of range. */
14970 if (CHARPOS (start_pos
) < BEGV
)
14971 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
14972 else if (CHARPOS (start_pos
) > ZV
)
14973 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
14975 /* Find the start of the continued line. This should be fast
14976 because scan_buffer is fast (newline cache). */
14977 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
14978 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
14979 row
, DEFAULT_FACE_ID
);
14980 reseat_at_previous_visible_line_start (&it
);
14982 /* If the line start is "too far" away from the window start,
14983 say it takes too much time to compute a new window start. */
14984 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
14985 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
14987 int min_distance
, distance
;
14989 /* Move forward by display lines to find the new window
14990 start. If window width was enlarged, the new start can
14991 be expected to be > the old start. If window width was
14992 decreased, the new window start will be < the old start.
14993 So, we're looking for the display line start with the
14994 minimum distance from the old window start. */
14995 pos
= it
.current
.pos
;
14996 min_distance
= INFINITY
;
14997 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
14998 distance
< min_distance
)
15000 min_distance
= distance
;
15001 pos
= it
.current
.pos
;
15002 move_it_by_lines (&it
, 1);
15005 /* Set the window start there. */
15006 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
15007 window_start_changed_p
= 1;
15011 return window_start_changed_p
;
15015 /* Try cursor movement in case text has not changed in window WINDOW,
15016 with window start STARTP. Value is
15018 CURSOR_MOVEMENT_SUCCESS if successful
15020 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
15022 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
15023 display. *SCROLL_STEP is set to 1, under certain circumstances, if
15024 we want to scroll as if scroll-step were set to 1. See the code.
15026 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
15027 which case we have to abort this redisplay, and adjust matrices
15032 CURSOR_MOVEMENT_SUCCESS
,
15033 CURSOR_MOVEMENT_CANNOT_BE_USED
,
15034 CURSOR_MOVEMENT_MUST_SCROLL
,
15035 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
15039 try_cursor_movement (Lisp_Object window
, struct text_pos startp
, int *scroll_step
)
15041 struct window
*w
= XWINDOW (window
);
15042 struct frame
*f
= XFRAME (w
->frame
);
15043 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
15046 if (inhibit_try_cursor_movement
)
15050 /* Previously, there was a check for Lisp integer in the
15051 if-statement below. Now, this field is converted to
15052 ptrdiff_t, thus zero means invalid position in a buffer. */
15053 eassert (w
->last_point
> 0);
15055 /* Handle case where text has not changed, only point, and it has
15056 not moved off the frame. */
15057 if (/* Point may be in this window. */
15058 PT
>= CHARPOS (startp
)
15059 /* Selective display hasn't changed. */
15060 && !current_buffer
->clip_changed
15061 /* Function force-mode-line-update is used to force a thorough
15062 redisplay. It sets either windows_or_buffers_changed or
15063 update_mode_lines. So don't take a shortcut here for these
15065 && !update_mode_lines
15066 && !windows_or_buffers_changed
15067 && !cursor_type_changed
15068 /* Can't use this case if highlighting a region. When a
15069 region exists, cursor movement has to do more than just
15071 && !(!NILP (Vtransient_mark_mode
)
15072 && !NILP (BVAR (current_buffer
, mark_active
)))
15073 && NILP (w
->region_showing
)
15074 && NILP (Vshow_trailing_whitespace
)
15075 /* This code is not used for mini-buffer for the sake of the case
15076 of redisplaying to replace an echo area message; since in
15077 that case the mini-buffer contents per se are usually
15078 unchanged. This code is of no real use in the mini-buffer
15079 since the handling of this_line_start_pos, etc., in redisplay
15080 handles the same cases. */
15081 && !EQ (window
, minibuf_window
)
15082 /* When splitting windows or for new windows, it happens that
15083 redisplay is called with a nil window_end_vpos or one being
15084 larger than the window. This should really be fixed in
15085 window.c. I don't have this on my list, now, so we do
15086 approximately the same as the old redisplay code. --gerd. */
15087 && INTEGERP (w
->window_end_vpos
)
15088 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
15089 && (FRAME_WINDOW_P (f
)
15090 || !overlay_arrow_in_current_buffer_p ()))
15092 int this_scroll_margin
, top_scroll_margin
;
15093 struct glyph_row
*row
= NULL
;
15096 debug_method_add (w
, "cursor movement");
15099 /* Scroll if point within this distance from the top or bottom
15100 of the window. This is a pixel value. */
15101 if (scroll_margin
> 0)
15103 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15104 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
15107 this_scroll_margin
= 0;
15109 top_scroll_margin
= this_scroll_margin
;
15110 if (WINDOW_WANTS_HEADER_LINE_P (w
))
15111 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
15113 /* Start with the row the cursor was displayed during the last
15114 not paused redisplay. Give up if that row is not valid. */
15115 if (w
->last_cursor
.vpos
< 0
15116 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
15117 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15120 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
15121 if (row
->mode_line_p
)
15123 if (!row
->enabled_p
)
15124 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15127 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
15129 int scroll_p
= 0, must_scroll
= 0;
15130 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
15132 if (PT
> w
->last_point
)
15134 /* Point has moved forward. */
15135 while (MATRIX_ROW_END_CHARPOS (row
) < PT
15136 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
15138 eassert (row
->enabled_p
);
15142 /* If the end position of a row equals the start
15143 position of the next row, and PT is at that position,
15144 we would rather display cursor in the next line. */
15145 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15146 && MATRIX_ROW_END_CHARPOS (row
) == PT
15147 && row
< w
->current_matrix
->rows
15148 + w
->current_matrix
->nrows
- 1
15149 && MATRIX_ROW_START_CHARPOS (row
+1) == PT
15150 && !cursor_row_p (row
))
15153 /* If within the scroll margin, scroll. Note that
15154 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
15155 the next line would be drawn, and that
15156 this_scroll_margin can be zero. */
15157 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
15158 || PT
> MATRIX_ROW_END_CHARPOS (row
)
15159 /* Line is completely visible last line in window
15160 and PT is to be set in the next line. */
15161 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
15162 && PT
== MATRIX_ROW_END_CHARPOS (row
)
15163 && !row
->ends_at_zv_p
15164 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
15167 else if (PT
< w
->last_point
)
15169 /* Cursor has to be moved backward. Note that PT >=
15170 CHARPOS (startp) because of the outer if-statement. */
15171 while (!row
->mode_line_p
15172 && (MATRIX_ROW_START_CHARPOS (row
) > PT
15173 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15174 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
15175 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
15176 row
> w
->current_matrix
->rows
15177 && (row
-1)->ends_in_newline_from_string_p
))))
15178 && (row
->y
> top_scroll_margin
15179 || CHARPOS (startp
) == BEGV
))
15181 eassert (row
->enabled_p
);
15185 /* Consider the following case: Window starts at BEGV,
15186 there is invisible, intangible text at BEGV, so that
15187 display starts at some point START > BEGV. It can
15188 happen that we are called with PT somewhere between
15189 BEGV and START. Try to handle that case. */
15190 if (row
< w
->current_matrix
->rows
15191 || row
->mode_line_p
)
15193 row
= w
->current_matrix
->rows
;
15194 if (row
->mode_line_p
)
15198 /* Due to newlines in overlay strings, we may have to
15199 skip forward over overlay strings. */
15200 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15201 && MATRIX_ROW_END_CHARPOS (row
) == PT
15202 && !cursor_row_p (row
))
15205 /* If within the scroll margin, scroll. */
15206 if (row
->y
< top_scroll_margin
15207 && CHARPOS (startp
) != BEGV
)
15212 /* Cursor did not move. So don't scroll even if cursor line
15213 is partially visible, as it was so before. */
15214 rc
= CURSOR_MOVEMENT_SUCCESS
;
15217 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
15218 || PT
> MATRIX_ROW_END_CHARPOS (row
))
15220 /* if PT is not in the glyph row, give up. */
15221 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15224 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15225 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15227 struct glyph_row
*row1
;
15229 /* If rows are bidi-reordered and point moved, back up
15230 until we find a row that does not belong to a
15231 continuation line. This is because we must consider
15232 all rows of a continued line as candidates for the
15233 new cursor positioning, since row start and end
15234 positions change non-linearly with vertical position
15236 /* FIXME: Revisit this when glyph ``spilling'' in
15237 continuation lines' rows is implemented for
15238 bidi-reordered rows. */
15239 for (row1
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15240 MATRIX_ROW_CONTINUATION_LINE_P (row
);
15243 /* If we hit the beginning of the displayed portion
15244 without finding the first row of a continued
15248 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15251 eassert (row
->enabled_p
);
15256 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15257 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
15258 /* Make sure this isn't a header line by any chance, since
15259 then MATRIX_ROW_PARTIALLY_VISIBLE_P might yield non-zero. */
15260 && !row
->mode_line_p
15261 && make_cursor_line_fully_visible_p
)
15263 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
15264 && !row
->ends_at_zv_p
15265 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
15266 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15267 else if (row
->height
> window_box_height (w
))
15269 /* If we end up in a partially visible line, let's
15270 make it fully visible, except when it's taller
15271 than the window, in which case we can't do much
15274 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15278 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15279 if (!cursor_row_fully_visible_p (w
, 0, 1))
15280 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15282 rc
= CURSOR_MOVEMENT_SUCCESS
;
15286 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15287 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15288 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15290 /* With bidi-reordered rows, there could be more than
15291 one candidate row whose start and end positions
15292 occlude point. We need to let set_cursor_from_row
15293 find the best candidate. */
15294 /* FIXME: Revisit this when glyph ``spilling'' in
15295 continuation lines' rows is implemented for
15296 bidi-reordered rows. */
15301 int at_zv_p
= 0, exact_match_p
= 0;
15303 if (MATRIX_ROW_START_CHARPOS (row
) <= PT
15304 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
15305 && cursor_row_p (row
))
15306 rv
|= set_cursor_from_row (w
, row
, w
->current_matrix
,
15308 /* As soon as we've found the exact match for point,
15309 or the first suitable row whose ends_at_zv_p flag
15310 is set, we are done. */
15312 MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
)->ends_at_zv_p
;
15314 && w
->cursor
.hpos
>= 0
15315 && w
->cursor
.hpos
< MATRIX_ROW_USED (w
->current_matrix
,
15318 struct glyph_row
*candidate
=
15319 MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
15321 candidate
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
15322 ptrdiff_t endpos
= MATRIX_ROW_END_CHARPOS (candidate
);
15325 (BUFFERP (g
->object
) && g
->charpos
== PT
)
15326 || (INTEGERP (g
->object
)
15327 && (g
->charpos
== PT
15328 || (g
->charpos
== 0 && endpos
- 1 == PT
)));
15330 if (rv
&& (at_zv_p
|| exact_match_p
))
15332 rc
= CURSOR_MOVEMENT_SUCCESS
;
15335 if (MATRIX_ROW_BOTTOM_Y (row
) == last_y
)
15339 while (((MATRIX_ROW_CONTINUATION_LINE_P (row
)
15340 || row
->continued_p
)
15341 && MATRIX_ROW_BOTTOM_Y (row
) <= last_y
)
15342 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15343 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
));
15344 /* If we didn't find any candidate rows, or exited the
15345 loop before all the candidates were examined, signal
15346 to the caller that this method failed. */
15347 if (rc
!= CURSOR_MOVEMENT_SUCCESS
15349 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
15350 && !row
->continued_p
))
15351 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15353 rc
= CURSOR_MOVEMENT_SUCCESS
;
15359 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
15361 rc
= CURSOR_MOVEMENT_SUCCESS
;
15366 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15367 && MATRIX_ROW_START_CHARPOS (row
) == PT
15368 && cursor_row_p (row
));
15376 #if !defined USE_TOOLKIT_SCROLL_BARS || defined USE_GTK
15380 set_vertical_scroll_bar (struct window
*w
)
15382 ptrdiff_t start
, end
, whole
;
15384 /* Calculate the start and end positions for the current window.
15385 At some point, it would be nice to choose between scrollbars
15386 which reflect the whole buffer size, with special markers
15387 indicating narrowing, and scrollbars which reflect only the
15390 Note that mini-buffers sometimes aren't displaying any text. */
15391 if (!MINI_WINDOW_P (w
)
15392 || (w
== XWINDOW (minibuf_window
)
15393 && NILP (echo_area_buffer
[0])))
15395 struct buffer
*buf
= XBUFFER (w
->buffer
);
15396 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
15397 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
15398 /* I don't think this is guaranteed to be right. For the
15399 moment, we'll pretend it is. */
15400 end
= BUF_Z (buf
) - XFASTINT (w
->window_end_pos
) - BUF_BEGV (buf
);
15404 if (whole
< (end
- start
))
15405 whole
= end
- start
;
15408 start
= end
= whole
= 0;
15410 /* Indicate what this scroll bar ought to be displaying now. */
15411 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15412 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15413 (w
, end
- start
, whole
, start
);
15417 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
15418 selected_window is redisplayed.
15420 We can return without actually redisplaying the window if
15421 fonts_changed_p. In that case, redisplay_internal will
15425 redisplay_window (Lisp_Object window
, int just_this_one_p
)
15427 struct window
*w
= XWINDOW (window
);
15428 struct frame
*f
= XFRAME (w
->frame
);
15429 struct buffer
*buffer
= XBUFFER (w
->buffer
);
15430 struct buffer
*old
= current_buffer
;
15431 struct text_pos lpoint
, opoint
, startp
;
15432 int update_mode_line
;
15435 /* Record it now because it's overwritten. */
15436 int current_matrix_up_to_date_p
= 0;
15437 int used_current_matrix_p
= 0;
15438 /* This is less strict than current_matrix_up_to_date_p.
15439 It indicates that the buffer contents and narrowing are unchanged. */
15440 int buffer_unchanged_p
= 0;
15441 int temp_scroll_step
= 0;
15442 ptrdiff_t count
= SPECPDL_INDEX ();
15444 int centering_position
= -1;
15445 int last_line_misfit
= 0;
15446 ptrdiff_t beg_unchanged
, end_unchanged
;
15448 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
15451 /* W must be a leaf window here. */
15452 eassert (!NILP (w
->buffer
));
15454 *w
->desired_matrix
->method
= 0;
15458 reconsider_clip_changes (w
, buffer
);
15460 /* Has the mode line to be updated? */
15461 update_mode_line
= (w
->update_mode_line
15462 || update_mode_lines
15463 || buffer
->clip_changed
15464 || buffer
->prevent_redisplay_optimizations_p
);
15466 if (MINI_WINDOW_P (w
))
15468 if (w
== XWINDOW (echo_area_window
)
15469 && !NILP (echo_area_buffer
[0]))
15471 if (update_mode_line
)
15472 /* We may have to update a tty frame's menu bar or a
15473 tool-bar. Example `M-x C-h C-h C-g'. */
15474 goto finish_menu_bars
;
15476 /* We've already displayed the echo area glyphs in this window. */
15477 goto finish_scroll_bars
;
15479 else if ((w
!= XWINDOW (minibuf_window
)
15480 || minibuf_level
== 0)
15481 /* When buffer is nonempty, redisplay window normally. */
15482 && BUF_Z (XBUFFER (w
->buffer
)) == BUF_BEG (XBUFFER (w
->buffer
))
15483 /* Quail displays non-mini buffers in minibuffer window.
15484 In that case, redisplay the window normally. */
15485 && !NILP (Fmemq (w
->buffer
, Vminibuffer_list
)))
15487 /* W is a mini-buffer window, but it's not active, so clear
15489 int yb
= window_text_bottom_y (w
);
15490 struct glyph_row
*row
;
15493 for (y
= 0, row
= w
->desired_matrix
->rows
;
15495 y
+= row
->height
, ++row
)
15496 blank_row (w
, row
, y
);
15497 goto finish_scroll_bars
;
15500 clear_glyph_matrix (w
->desired_matrix
);
15503 /* Otherwise set up data on this window; select its buffer and point
15505 /* Really select the buffer, for the sake of buffer-local
15507 set_buffer_internal_1 (XBUFFER (w
->buffer
));
15509 current_matrix_up_to_date_p
15510 = (!NILP (w
->window_end_valid
)
15511 && !current_buffer
->clip_changed
15512 && !current_buffer
->prevent_redisplay_optimizations_p
15513 && w
->last_modified
>= MODIFF
15514 && w
->last_overlay_modified
>= OVERLAY_MODIFF
);
15516 /* Run the window-bottom-change-functions
15517 if it is possible that the text on the screen has changed
15518 (either due to modification of the text, or any other reason). */
15519 if (!current_matrix_up_to_date_p
15520 && !NILP (Vwindow_text_change_functions
))
15522 safe_run_hooks (Qwindow_text_change_functions
);
15526 beg_unchanged
= BEG_UNCHANGED
;
15527 end_unchanged
= END_UNCHANGED
;
15529 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
15531 specbind (Qinhibit_point_motion_hooks
, Qt
);
15534 = (!NILP (w
->window_end_valid
)
15535 && !current_buffer
->clip_changed
15536 && w
->last_modified
>= MODIFF
15537 && w
->last_overlay_modified
>= OVERLAY_MODIFF
);
15539 /* When windows_or_buffers_changed is non-zero, we can't rely on
15540 the window end being valid, so set it to nil there. */
15541 if (windows_or_buffers_changed
)
15543 /* If window starts on a continuation line, maybe adjust the
15544 window start in case the window's width changed. */
15545 if (XMARKER (w
->start
)->buffer
== current_buffer
)
15546 compute_window_start_on_continuation_line (w
);
15548 wset_window_end_valid (w
, Qnil
);
15551 /* Some sanity checks. */
15552 CHECK_WINDOW_END (w
);
15553 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
15555 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
15558 /* If %c is in mode line, update it if needed. */
15559 if (!NILP (w
->column_number_displayed
)
15560 /* This alternative quickly identifies a common case
15561 where no change is needed. */
15562 && !(PT
== w
->last_point
15563 && w
->last_modified
>= MODIFF
15564 && w
->last_overlay_modified
>= OVERLAY_MODIFF
)
15565 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
15566 update_mode_line
= 1;
15568 /* Count number of windows showing the selected buffer. An indirect
15569 buffer counts as its base buffer. */
15570 if (!just_this_one_p
)
15572 struct buffer
*current_base
, *window_base
;
15573 current_base
= current_buffer
;
15574 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
15575 if (current_base
->base_buffer
)
15576 current_base
= current_base
->base_buffer
;
15577 if (window_base
->base_buffer
)
15578 window_base
= window_base
->base_buffer
;
15579 if (current_base
== window_base
)
15583 /* Point refers normally to the selected window. For any other
15584 window, set up appropriate value. */
15585 if (!EQ (window
, selected_window
))
15587 ptrdiff_t new_pt
= XMARKER (w
->pointm
)->charpos
;
15588 ptrdiff_t new_pt_byte
= marker_byte_position (w
->pointm
);
15592 new_pt_byte
= BEGV_BYTE
;
15593 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
15595 else if (new_pt
> (ZV
- 1))
15598 new_pt_byte
= ZV_BYTE
;
15599 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
15602 /* We don't use SET_PT so that the point-motion hooks don't run. */
15603 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
15606 /* If any of the character widths specified in the display table
15607 have changed, invalidate the width run cache. It's true that
15608 this may be a bit late to catch such changes, but the rest of
15609 redisplay goes (non-fatally) haywire when the display table is
15610 changed, so why should we worry about doing any better? */
15611 if (current_buffer
->width_run_cache
)
15613 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
15615 if (! disptab_matches_widthtab
15616 (disptab
, XVECTOR (BVAR (current_buffer
, width_table
))))
15618 invalidate_region_cache (current_buffer
,
15619 current_buffer
->width_run_cache
,
15621 recompute_width_table (current_buffer
, disptab
);
15625 /* If window-start is screwed up, choose a new one. */
15626 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
15629 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15631 /* If someone specified a new starting point but did not insist,
15632 check whether it can be used. */
15633 if (w
->optional_new_start
15634 && CHARPOS (startp
) >= BEGV
15635 && CHARPOS (startp
) <= ZV
)
15637 w
->optional_new_start
= 0;
15638 start_display (&it
, w
, startp
);
15639 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
15640 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
15641 if (IT_CHARPOS (it
) == PT
)
15642 w
->force_start
= 1;
15643 /* IT may overshoot PT if text at PT is invisible. */
15644 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
15645 w
->force_start
= 1;
15650 /* Handle case where place to start displaying has been specified,
15651 unless the specified location is outside the accessible range. */
15652 if (w
->force_start
|| w
->frozen_window_start_p
)
15654 /* We set this later on if we have to adjust point. */
15657 w
->force_start
= 0;
15659 wset_window_end_valid (w
, Qnil
);
15661 /* Forget any recorded base line for line number display. */
15662 if (!buffer_unchanged_p
)
15663 wset_base_line_number (w
, Qnil
);
15665 /* Redisplay the mode line. Select the buffer properly for that.
15666 Also, run the hook window-scroll-functions
15667 because we have scrolled. */
15668 /* Note, we do this after clearing force_start because
15669 if there's an error, it is better to forget about force_start
15670 than to get into an infinite loop calling the hook functions
15671 and having them get more errors. */
15672 if (!update_mode_line
15673 || ! NILP (Vwindow_scroll_functions
))
15675 update_mode_line
= 1;
15676 w
->update_mode_line
= 1;
15677 startp
= run_window_scroll_functions (window
, startp
);
15680 w
->last_modified
= 0;
15681 w
->last_overlay_modified
= 0;
15682 if (CHARPOS (startp
) < BEGV
)
15683 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
15684 else if (CHARPOS (startp
) > ZV
)
15685 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
15687 /* Redisplay, then check if cursor has been set during the
15688 redisplay. Give up if new fonts were loaded. */
15689 /* We used to issue a CHECK_MARGINS argument to try_window here,
15690 but this causes scrolling to fail when point begins inside
15691 the scroll margin (bug#148) -- cyd */
15692 if (!try_window (window
, startp
, 0))
15694 w
->force_start
= 1;
15695 clear_glyph_matrix (w
->desired_matrix
);
15696 goto need_larger_matrices
;
15699 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
15701 /* If point does not appear, try to move point so it does
15702 appear. The desired matrix has been built above, so we
15703 can use it here. */
15704 new_vpos
= window_box_height (w
) / 2;
15707 if (!cursor_row_fully_visible_p (w
, 0, 0))
15709 /* Point does appear, but on a line partly visible at end of window.
15710 Move it back to a fully-visible line. */
15711 new_vpos
= window_box_height (w
);
15714 /* If we need to move point for either of the above reasons,
15715 now actually do it. */
15718 struct glyph_row
*row
;
15720 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
15721 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
15724 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
15725 MATRIX_ROW_START_BYTEPOS (row
));
15727 if (w
!= XWINDOW (selected_window
))
15728 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
15729 else if (current_buffer
== old
)
15730 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
15732 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
15734 /* If we are highlighting the region, then we just changed
15735 the region, so redisplay to show it. */
15736 if (!NILP (Vtransient_mark_mode
)
15737 && !NILP (BVAR (current_buffer
, mark_active
)))
15739 clear_glyph_matrix (w
->desired_matrix
);
15740 if (!try_window (window
, startp
, 0))
15741 goto need_larger_matrices
;
15746 debug_method_add (w
, "forced window start");
15751 /* Handle case where text has not changed, only point, and it has
15752 not moved off the frame, and we are not retrying after hscroll.
15753 (current_matrix_up_to_date_p is nonzero when retrying.) */
15754 if (current_matrix_up_to_date_p
15755 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
15756 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
15760 case CURSOR_MOVEMENT_SUCCESS
:
15761 used_current_matrix_p
= 1;
15764 case CURSOR_MOVEMENT_MUST_SCROLL
:
15765 goto try_to_scroll
;
15771 /* If current starting point was originally the beginning of a line
15772 but no longer is, find a new starting point. */
15773 else if (w
->start_at_line_beg
15774 && !(CHARPOS (startp
) <= BEGV
15775 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
15778 debug_method_add (w
, "recenter 1");
15783 /* Try scrolling with try_window_id. Value is > 0 if update has
15784 been done, it is -1 if we know that the same window start will
15785 not work. It is 0 if unsuccessful for some other reason. */
15786 else if ((tem
= try_window_id (w
)) != 0)
15789 debug_method_add (w
, "try_window_id %d", tem
);
15792 if (fonts_changed_p
)
15793 goto need_larger_matrices
;
15797 /* Otherwise try_window_id has returned -1 which means that we
15798 don't want the alternative below this comment to execute. */
15800 else if (CHARPOS (startp
) >= BEGV
15801 && CHARPOS (startp
) <= ZV
15802 && PT
>= CHARPOS (startp
)
15803 && (CHARPOS (startp
) < ZV
15804 /* Avoid starting at end of buffer. */
15805 || CHARPOS (startp
) == BEGV
15806 || (w
->last_modified
>= MODIFF
15807 && w
->last_overlay_modified
>= OVERLAY_MODIFF
)))
15809 int d1
, d2
, d3
, d4
, d5
, d6
;
15811 /* If first window line is a continuation line, and window start
15812 is inside the modified region, but the first change is before
15813 current window start, we must select a new window start.
15815 However, if this is the result of a down-mouse event (e.g. by
15816 extending the mouse-drag-overlay), we don't want to select a
15817 new window start, since that would change the position under
15818 the mouse, resulting in an unwanted mouse-movement rather
15819 than a simple mouse-click. */
15820 if (!w
->start_at_line_beg
15821 && NILP (do_mouse_tracking
)
15822 && CHARPOS (startp
) > BEGV
15823 && CHARPOS (startp
) > BEG
+ beg_unchanged
15824 && CHARPOS (startp
) <= Z
- end_unchanged
15825 /* Even if w->start_at_line_beg is nil, a new window may
15826 start at a line_beg, since that's how set_buffer_window
15827 sets it. So, we need to check the return value of
15828 compute_window_start_on_continuation_line. (See also
15830 && XMARKER (w
->start
)->buffer
== current_buffer
15831 && compute_window_start_on_continuation_line (w
)
15832 /* It doesn't make sense to force the window start like we
15833 do at label force_start if it is already known that point
15834 will not be visible in the resulting window, because
15835 doing so will move point from its correct position
15836 instead of scrolling the window to bring point into view.
15838 && pos_visible_p (w
, PT
, &d1
, &d2
, &d3
, &d4
, &d5
, &d6
))
15840 w
->force_start
= 1;
15841 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15846 debug_method_add (w
, "same window start");
15849 /* Try to redisplay starting at same place as before.
15850 If point has not moved off frame, accept the results. */
15851 if (!current_matrix_up_to_date_p
15852 /* Don't use try_window_reusing_current_matrix in this case
15853 because a window scroll function can have changed the
15855 || !NILP (Vwindow_scroll_functions
)
15856 || MINI_WINDOW_P (w
)
15857 || !(used_current_matrix_p
15858 = try_window_reusing_current_matrix (w
)))
15860 IF_DEBUG (debug_method_add (w
, "1"));
15861 if (try_window (window
, startp
, TRY_WINDOW_CHECK_MARGINS
) < 0)
15862 /* -1 means we need to scroll.
15863 0 means we need new matrices, but fonts_changed_p
15864 is set in that case, so we will detect it below. */
15865 goto try_to_scroll
;
15868 if (fonts_changed_p
)
15869 goto need_larger_matrices
;
15871 if (w
->cursor
.vpos
>= 0)
15873 if (!just_this_one_p
15874 || current_buffer
->clip_changed
15875 || BEG_UNCHANGED
< CHARPOS (startp
))
15876 /* Forget any recorded base line for line number display. */
15877 wset_base_line_number (w
, Qnil
);
15879 if (!cursor_row_fully_visible_p (w
, 1, 0))
15881 clear_glyph_matrix (w
->desired_matrix
);
15882 last_line_misfit
= 1;
15884 /* Drop through and scroll. */
15889 clear_glyph_matrix (w
->desired_matrix
);
15894 w
->last_modified
= 0;
15895 w
->last_overlay_modified
= 0;
15897 /* Redisplay the mode line. Select the buffer properly for that. */
15898 if (!update_mode_line
)
15900 update_mode_line
= 1;
15901 w
->update_mode_line
= 1;
15904 /* Try to scroll by specified few lines. */
15905 if ((scroll_conservatively
15906 || emacs_scroll_step
15907 || temp_scroll_step
15908 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
))
15909 || NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
)))
15910 && CHARPOS (startp
) >= BEGV
15911 && CHARPOS (startp
) <= ZV
)
15913 /* The function returns -1 if new fonts were loaded, 1 if
15914 successful, 0 if not successful. */
15915 int ss
= try_scrolling (window
, just_this_one_p
,
15916 scroll_conservatively
,
15918 temp_scroll_step
, last_line_misfit
);
15921 case SCROLLING_SUCCESS
:
15924 case SCROLLING_NEED_LARGER_MATRICES
:
15925 goto need_larger_matrices
;
15927 case SCROLLING_FAILED
:
15935 /* Finally, just choose a place to start which positions point
15936 according to user preferences. */
15941 debug_method_add (w
, "recenter");
15944 /* w->vscroll = 0; */
15946 /* Forget any previously recorded base line for line number display. */
15947 if (!buffer_unchanged_p
)
15948 wset_base_line_number (w
, Qnil
);
15950 /* Determine the window start relative to point. */
15951 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
15952 it
.current_y
= it
.last_visible_y
;
15953 if (centering_position
< 0)
15957 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
15959 ptrdiff_t margin_pos
= CHARPOS (startp
);
15960 Lisp_Object aggressive
;
15963 /* If there is a scroll margin at the top of the window, find
15964 its character position. */
15966 /* Cannot call start_display if startp is not in the
15967 accessible region of the buffer. This can happen when we
15968 have just switched to a different buffer and/or changed
15969 its restriction. In that case, startp is initialized to
15970 the character position 1 (BEGV) because we did not yet
15971 have chance to display the buffer even once. */
15972 && BEGV
<= CHARPOS (startp
) && CHARPOS (startp
) <= ZV
)
15975 void *it1data
= NULL
;
15977 SAVE_IT (it1
, it
, it1data
);
15978 start_display (&it1
, w
, startp
);
15979 move_it_vertically (&it1
, margin
* FRAME_LINE_HEIGHT (f
));
15980 margin_pos
= IT_CHARPOS (it1
);
15981 RESTORE_IT (&it
, &it
, it1data
);
15983 scrolling_up
= PT
> margin_pos
;
15986 ? BVAR (current_buffer
, scroll_up_aggressively
)
15987 : BVAR (current_buffer
, scroll_down_aggressively
);
15989 if (!MINI_WINDOW_P (w
)
15990 && (scroll_conservatively
> SCROLL_LIMIT
|| NUMBERP (aggressive
)))
15994 /* Setting scroll-conservatively overrides
15995 scroll-*-aggressively. */
15996 if (!scroll_conservatively
&& NUMBERP (aggressive
))
15998 double float_amount
= XFLOATINT (aggressive
);
16000 pt_offset
= float_amount
* WINDOW_BOX_TEXT_HEIGHT (w
);
16001 if (pt_offset
== 0 && float_amount
> 0)
16003 if (pt_offset
&& margin
> 0)
16006 /* Compute how much to move the window start backward from
16007 point so that point will be displayed where the user
16011 centering_position
= it
.last_visible_y
;
16013 centering_position
-= pt_offset
;
16014 centering_position
-=
16015 FRAME_LINE_HEIGHT (f
) * (1 + margin
+ (last_line_misfit
!= 0))
16016 + WINDOW_HEADER_LINE_HEIGHT (w
);
16017 /* Don't let point enter the scroll margin near top of
16019 if (centering_position
< margin
* FRAME_LINE_HEIGHT (f
))
16020 centering_position
= margin
* FRAME_LINE_HEIGHT (f
);
16023 centering_position
= margin
* FRAME_LINE_HEIGHT (f
) + pt_offset
;
16026 /* Set the window start half the height of the window backward
16028 centering_position
= window_box_height (w
) / 2;
16030 move_it_vertically_backward (&it
, centering_position
);
16032 eassert (IT_CHARPOS (it
) >= BEGV
);
16034 /* The function move_it_vertically_backward may move over more
16035 than the specified y-distance. If it->w is small, e.g. a
16036 mini-buffer window, we may end up in front of the window's
16037 display area. Start displaying at the start of the line
16038 containing PT in this case. */
16039 if (it
.current_y
<= 0)
16041 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
16042 move_it_vertically_backward (&it
, 0);
16046 it
.current_x
= it
.hpos
= 0;
16048 /* Set the window start position here explicitly, to avoid an
16049 infinite loop in case the functions in window-scroll-functions
16051 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
16053 /* Run scroll hooks. */
16054 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
16056 /* Redisplay the window. */
16057 if (!current_matrix_up_to_date_p
16058 || windows_or_buffers_changed
16059 || cursor_type_changed
16060 /* Don't use try_window_reusing_current_matrix in this case
16061 because it can have changed the buffer. */
16062 || !NILP (Vwindow_scroll_functions
)
16063 || !just_this_one_p
16064 || MINI_WINDOW_P (w
)
16065 || !(used_current_matrix_p
16066 = try_window_reusing_current_matrix (w
)))
16067 try_window (window
, startp
, 0);
16069 /* If new fonts have been loaded (due to fontsets), give up. We
16070 have to start a new redisplay since we need to re-adjust glyph
16072 if (fonts_changed_p
)
16073 goto need_larger_matrices
;
16075 /* If cursor did not appear assume that the middle of the window is
16076 in the first line of the window. Do it again with the next line.
16077 (Imagine a window of height 100, displaying two lines of height
16078 60. Moving back 50 from it->last_visible_y will end in the first
16080 if (w
->cursor
.vpos
< 0)
16082 if (!NILP (w
->window_end_valid
)
16083 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
16085 clear_glyph_matrix (w
->desired_matrix
);
16086 move_it_by_lines (&it
, 1);
16087 try_window (window
, it
.current
.pos
, 0);
16089 else if (PT
< IT_CHARPOS (it
))
16091 clear_glyph_matrix (w
->desired_matrix
);
16092 move_it_by_lines (&it
, -1);
16093 try_window (window
, it
.current
.pos
, 0);
16097 /* Not much we can do about it. */
16101 /* Consider the following case: Window starts at BEGV, there is
16102 invisible, intangible text at BEGV, so that display starts at
16103 some point START > BEGV. It can happen that we are called with
16104 PT somewhere between BEGV and START. Try to handle that case. */
16105 if (w
->cursor
.vpos
< 0)
16107 struct glyph_row
*row
= w
->current_matrix
->rows
;
16108 if (row
->mode_line_p
)
16110 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
16113 if (!cursor_row_fully_visible_p (w
, 0, 0))
16115 /* If vscroll is enabled, disable it and try again. */
16119 clear_glyph_matrix (w
->desired_matrix
);
16123 /* Users who set scroll-conservatively to a large number want
16124 point just above/below the scroll margin. If we ended up
16125 with point's row partially visible, move the window start to
16126 make that row fully visible and out of the margin. */
16127 if (scroll_conservatively
> SCROLL_LIMIT
)
16131 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
16133 int move_down
= w
->cursor
.vpos
>= WINDOW_TOTAL_LINES (w
) / 2;
16135 move_it_by_lines (&it
, move_down
? margin
+ 1 : -(margin
+ 1));
16136 clear_glyph_matrix (w
->desired_matrix
);
16137 if (1 == try_window (window
, it
.current
.pos
,
16138 TRY_WINDOW_CHECK_MARGINS
))
16142 /* If centering point failed to make the whole line visible,
16143 put point at the top instead. That has to make the whole line
16144 visible, if it can be done. */
16145 if (centering_position
== 0)
16148 clear_glyph_matrix (w
->desired_matrix
);
16149 centering_position
= 0;
16155 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
16156 w
->start_at_line_beg
= (CHARPOS (startp
) == BEGV
16157 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n');
16159 /* Display the mode line, if we must. */
16160 if ((update_mode_line
16161 /* If window not full width, must redo its mode line
16162 if (a) the window to its side is being redone and
16163 (b) we do a frame-based redisplay. This is a consequence
16164 of how inverted lines are drawn in frame-based redisplay. */
16165 || (!just_this_one_p
16166 && !FRAME_WINDOW_P (f
)
16167 && !WINDOW_FULL_WIDTH_P (w
))
16168 /* Line number to display. */
16169 || INTEGERP (w
->base_line_pos
)
16170 /* Column number is displayed and different from the one displayed. */
16171 || (!NILP (w
->column_number_displayed
)
16172 && (XFASTINT (w
->column_number_displayed
) != current_column ())))
16173 /* This means that the window has a mode line. */
16174 && (WINDOW_WANTS_MODELINE_P (w
)
16175 || WINDOW_WANTS_HEADER_LINE_P (w
)))
16177 display_mode_lines (w
);
16179 /* If mode line height has changed, arrange for a thorough
16180 immediate redisplay using the correct mode line height. */
16181 if (WINDOW_WANTS_MODELINE_P (w
)
16182 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
16184 fonts_changed_p
= 1;
16185 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
16186 = DESIRED_MODE_LINE_HEIGHT (w
);
16189 /* If header line height has changed, arrange for a thorough
16190 immediate redisplay using the correct header line height. */
16191 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16192 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
16194 fonts_changed_p
= 1;
16195 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
16196 = DESIRED_HEADER_LINE_HEIGHT (w
);
16199 if (fonts_changed_p
)
16200 goto need_larger_matrices
;
16203 if (!line_number_displayed
16204 && !BUFFERP (w
->base_line_pos
))
16206 wset_base_line_pos (w
, Qnil
);
16207 wset_base_line_number (w
, Qnil
);
16212 /* When we reach a frame's selected window, redo the frame's menu bar. */
16213 if (update_mode_line
16214 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
16216 int redisplay_menu_p
= 0;
16218 if (FRAME_WINDOW_P (f
))
16220 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
16221 || defined (HAVE_NS) || defined (USE_GTK)
16222 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
16224 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16228 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16230 if (redisplay_menu_p
)
16231 display_menu_bar (w
);
16233 #ifdef HAVE_WINDOW_SYSTEM
16234 if (FRAME_WINDOW_P (f
))
16236 #if defined (USE_GTK) || defined (HAVE_NS)
16237 if (FRAME_EXTERNAL_TOOL_BAR (f
))
16238 redisplay_tool_bar (f
);
16240 if (WINDOWP (f
->tool_bar_window
)
16241 && (FRAME_TOOL_BAR_LINES (f
) > 0
16242 || !NILP (Vauto_resize_tool_bars
))
16243 && redisplay_tool_bar (f
))
16244 ignore_mouse_drag_p
= 1;
16250 #ifdef HAVE_WINDOW_SYSTEM
16251 if (FRAME_WINDOW_P (f
)
16252 && update_window_fringes (w
, (just_this_one_p
16253 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
16254 || w
->pseudo_window_p
)))
16258 if (draw_window_fringes (w
, 1))
16259 x_draw_vertical_border (w
);
16263 #endif /* HAVE_WINDOW_SYSTEM */
16265 /* We go to this label, with fonts_changed_p set,
16266 if it is necessary to try again using larger glyph matrices.
16267 We have to redeem the scroll bar even in this case,
16268 because the loop in redisplay_internal expects that. */
16269 need_larger_matrices
:
16271 finish_scroll_bars
:
16273 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
16275 /* Set the thumb's position and size. */
16276 set_vertical_scroll_bar (w
);
16278 /* Note that we actually used the scroll bar attached to this
16279 window, so it shouldn't be deleted at the end of redisplay. */
16280 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
16281 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
16284 /* Restore current_buffer and value of point in it. The window
16285 update may have changed the buffer, so first make sure `opoint'
16286 is still valid (Bug#6177). */
16287 if (CHARPOS (opoint
) < BEGV
)
16288 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
16289 else if (CHARPOS (opoint
) > ZV
)
16290 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
16292 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
16294 set_buffer_internal_1 (old
);
16295 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
16296 shorter. This can be caused by log truncation in *Messages*. */
16297 if (CHARPOS (lpoint
) <= ZV
)
16298 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
16300 unbind_to (count
, Qnil
);
16304 /* Build the complete desired matrix of WINDOW with a window start
16305 buffer position POS.
16307 Value is 1 if successful. It is zero if fonts were loaded during
16308 redisplay which makes re-adjusting glyph matrices necessary, and -1
16309 if point would appear in the scroll margins.
16310 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
16311 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
16315 try_window (Lisp_Object window
, struct text_pos pos
, int flags
)
16317 struct window
*w
= XWINDOW (window
);
16319 struct glyph_row
*last_text_row
= NULL
;
16320 struct frame
*f
= XFRAME (w
->frame
);
16322 /* Make POS the new window start. */
16323 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
16325 /* Mark cursor position as unknown. No overlay arrow seen. */
16326 w
->cursor
.vpos
= -1;
16327 overlay_arrow_seen
= 0;
16329 /* Initialize iterator and info to start at POS. */
16330 start_display (&it
, w
, pos
);
16332 /* Display all lines of W. */
16333 while (it
.current_y
< it
.last_visible_y
)
16335 if (display_line (&it
))
16336 last_text_row
= it
.glyph_row
- 1;
16337 if (fonts_changed_p
&& !(flags
& TRY_WINDOW_IGNORE_FONTS_CHANGE
))
16341 /* Don't let the cursor end in the scroll margins. */
16342 if ((flags
& TRY_WINDOW_CHECK_MARGINS
)
16343 && !MINI_WINDOW_P (w
))
16345 int this_scroll_margin
;
16347 if (scroll_margin
> 0)
16349 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
16350 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
16353 this_scroll_margin
= 0;
16355 if ((w
->cursor
.y
>= 0 /* not vscrolled */
16356 && w
->cursor
.y
< this_scroll_margin
16357 && CHARPOS (pos
) > BEGV
16358 && IT_CHARPOS (it
) < ZV
)
16359 /* rms: considering make_cursor_line_fully_visible_p here
16360 seems to give wrong results. We don't want to recenter
16361 when the last line is partly visible, we want to allow
16362 that case to be handled in the usual way. */
16363 || w
->cursor
.y
> it
.last_visible_y
- this_scroll_margin
- 1)
16365 w
->cursor
.vpos
= -1;
16366 clear_glyph_matrix (w
->desired_matrix
);
16371 /* If bottom moved off end of frame, change mode line percentage. */
16372 if (XFASTINT (w
->window_end_pos
) <= 0
16373 && Z
!= IT_CHARPOS (it
))
16374 w
->update_mode_line
= 1;
16376 /* Set window_end_pos to the offset of the last character displayed
16377 on the window from the end of current_buffer. Set
16378 window_end_vpos to its row number. */
16381 eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
16382 w
->window_end_bytepos
16383 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16384 wset_window_end_pos
16385 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16386 wset_window_end_vpos
16387 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
)));
16389 (MATRIX_ROW (w
->desired_matrix
,
16390 XFASTINT (w
->window_end_vpos
))->displays_text_p
);
16394 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
16395 wset_window_end_pos (w
, make_number (Z
- ZV
));
16396 wset_window_end_vpos (w
, make_number (0));
16399 /* But that is not valid info until redisplay finishes. */
16400 wset_window_end_valid (w
, Qnil
);
16406 /************************************************************************
16407 Window redisplay reusing current matrix when buffer has not changed
16408 ************************************************************************/
16410 /* Try redisplay of window W showing an unchanged buffer with a
16411 different window start than the last time it was displayed by
16412 reusing its current matrix. Value is non-zero if successful.
16413 W->start is the new window start. */
16416 try_window_reusing_current_matrix (struct window
*w
)
16418 struct frame
*f
= XFRAME (w
->frame
);
16419 struct glyph_row
*bottom_row
;
16422 struct text_pos start
, new_start
;
16423 int nrows_scrolled
, i
;
16424 struct glyph_row
*last_text_row
;
16425 struct glyph_row
*last_reused_text_row
;
16426 struct glyph_row
*start_row
;
16427 int start_vpos
, min_y
, max_y
;
16430 if (inhibit_try_window_reusing
)
16434 if (/* This function doesn't handle terminal frames. */
16435 !FRAME_WINDOW_P (f
)
16436 /* Don't try to reuse the display if windows have been split
16438 || windows_or_buffers_changed
16439 || cursor_type_changed
)
16442 /* Can't do this if region may have changed. */
16443 if ((!NILP (Vtransient_mark_mode
)
16444 && !NILP (BVAR (current_buffer
, mark_active
)))
16445 || !NILP (w
->region_showing
)
16446 || !NILP (Vshow_trailing_whitespace
))
16449 /* If top-line visibility has changed, give up. */
16450 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16451 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
16454 /* Give up if old or new display is scrolled vertically. We could
16455 make this function handle this, but right now it doesn't. */
16456 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16457 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
16460 /* The variable new_start now holds the new window start. The old
16461 start `start' can be determined from the current matrix. */
16462 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
16463 start
= start_row
->minpos
;
16464 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16466 /* Clear the desired matrix for the display below. */
16467 clear_glyph_matrix (w
->desired_matrix
);
16469 if (CHARPOS (new_start
) <= CHARPOS (start
))
16471 /* Don't use this method if the display starts with an ellipsis
16472 displayed for invisible text. It's not easy to handle that case
16473 below, and it's certainly not worth the effort since this is
16474 not a frequent case. */
16475 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
16478 IF_DEBUG (debug_method_add (w
, "twu1"));
16480 /* Display up to a row that can be reused. The variable
16481 last_text_row is set to the last row displayed that displays
16482 text. Note that it.vpos == 0 if or if not there is a
16483 header-line; it's not the same as the MATRIX_ROW_VPOS! */
16484 start_display (&it
, w
, new_start
);
16485 w
->cursor
.vpos
= -1;
16486 last_text_row
= last_reused_text_row
= NULL
;
16488 while (it
.current_y
< it
.last_visible_y
16489 && !fonts_changed_p
)
16491 /* If we have reached into the characters in the START row,
16492 that means the line boundaries have changed. So we
16493 can't start copying with the row START. Maybe it will
16494 work to start copying with the following row. */
16495 while (IT_CHARPOS (it
) > CHARPOS (start
))
16497 /* Advance to the next row as the "start". */
16499 start
= start_row
->minpos
;
16500 /* If there are no more rows to try, or just one, give up. */
16501 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
16502 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
16503 || CHARPOS (start
) == ZV
)
16505 clear_glyph_matrix (w
->desired_matrix
);
16509 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16511 /* If we have reached alignment, we can copy the rest of the
16513 if (IT_CHARPOS (it
) == CHARPOS (start
)
16514 /* Don't accept "alignment" inside a display vector,
16515 since start_row could have started in the middle of
16516 that same display vector (thus their character
16517 positions match), and we have no way of telling if
16518 that is the case. */
16519 && it
.current
.dpvec_index
< 0)
16522 if (display_line (&it
))
16523 last_text_row
= it
.glyph_row
- 1;
16527 /* A value of current_y < last_visible_y means that we stopped
16528 at the previous window start, which in turn means that we
16529 have at least one reusable row. */
16530 if (it
.current_y
< it
.last_visible_y
)
16532 struct glyph_row
*row
;
16534 /* IT.vpos always starts from 0; it counts text lines. */
16535 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
16537 /* Find PT if not already found in the lines displayed. */
16538 if (w
->cursor
.vpos
< 0)
16540 int dy
= it
.current_y
- start_row
->y
;
16542 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16543 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
16545 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
16546 dy
, nrows_scrolled
);
16549 clear_glyph_matrix (w
->desired_matrix
);
16554 /* Scroll the display. Do it before the current matrix is
16555 changed. The problem here is that update has not yet
16556 run, i.e. part of the current matrix is not up to date.
16557 scroll_run_hook will clear the cursor, and use the
16558 current matrix to get the height of the row the cursor is
16560 run
.current_y
= start_row
->y
;
16561 run
.desired_y
= it
.current_y
;
16562 run
.height
= it
.last_visible_y
- it
.current_y
;
16564 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
16567 FRAME_RIF (f
)->update_window_begin_hook (w
);
16568 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16569 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16570 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16574 /* Shift current matrix down by nrows_scrolled lines. */
16575 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
16576 rotate_matrix (w
->current_matrix
,
16578 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
16581 /* Disable lines that must be updated. */
16582 for (i
= 0; i
< nrows_scrolled
; ++i
)
16583 (start_row
+ i
)->enabled_p
= 0;
16585 /* Re-compute Y positions. */
16586 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16587 max_y
= it
.last_visible_y
;
16588 for (row
= start_row
+ nrows_scrolled
;
16592 row
->y
= it
.current_y
;
16593 row
->visible_height
= row
->height
;
16595 if (row
->y
< min_y
)
16596 row
->visible_height
-= min_y
- row
->y
;
16597 if (row
->y
+ row
->height
> max_y
)
16598 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
16599 if (row
->fringe_bitmap_periodic_p
)
16600 row
->redraw_fringe_bitmaps_p
= 1;
16602 it
.current_y
+= row
->height
;
16604 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16605 last_reused_text_row
= row
;
16606 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
16610 /* Disable lines in the current matrix which are now
16611 below the window. */
16612 for (++row
; row
< bottom_row
; ++row
)
16613 row
->enabled_p
= row
->mode_line_p
= 0;
16616 /* Update window_end_pos etc.; last_reused_text_row is the last
16617 reused row from the current matrix containing text, if any.
16618 The value of last_text_row is the last displayed line
16619 containing text. */
16620 if (last_reused_text_row
)
16622 w
->window_end_bytepos
16623 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
16624 wset_window_end_pos
16626 - MATRIX_ROW_END_CHARPOS (last_reused_text_row
)));
16627 wset_window_end_vpos
16628 (w
, make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
16629 w
->current_matrix
)));
16631 else if (last_text_row
)
16633 w
->window_end_bytepos
16634 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16635 wset_window_end_pos
16636 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16637 wset_window_end_vpos
16638 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
,
16639 w
->desired_matrix
)));
16643 /* This window must be completely empty. */
16644 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
16645 wset_window_end_pos (w
, make_number (Z
- ZV
));
16646 wset_window_end_vpos (w
, make_number (0));
16648 wset_window_end_valid (w
, Qnil
);
16650 /* Update hint: don't try scrolling again in update_window. */
16651 w
->desired_matrix
->no_scrolling_p
= 1;
16654 debug_method_add (w
, "try_window_reusing_current_matrix 1");
16658 else if (CHARPOS (new_start
) > CHARPOS (start
))
16660 struct glyph_row
*pt_row
, *row
;
16661 struct glyph_row
*first_reusable_row
;
16662 struct glyph_row
*first_row_to_display
;
16664 int yb
= window_text_bottom_y (w
);
16666 /* Find the row starting at new_start, if there is one. Don't
16667 reuse a partially visible line at the end. */
16668 first_reusable_row
= start_row
;
16669 while (first_reusable_row
->enabled_p
16670 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
16671 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
16672 < CHARPOS (new_start
)))
16673 ++first_reusable_row
;
16675 /* Give up if there is no row to reuse. */
16676 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
16677 || !first_reusable_row
->enabled_p
16678 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
16679 != CHARPOS (new_start
)))
16682 /* We can reuse fully visible rows beginning with
16683 first_reusable_row to the end of the window. Set
16684 first_row_to_display to the first row that cannot be reused.
16685 Set pt_row to the row containing point, if there is any. */
16687 for (first_row_to_display
= first_reusable_row
;
16688 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
16689 ++first_row_to_display
)
16691 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
16692 && (PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
)
16693 || (PT
== MATRIX_ROW_END_CHARPOS (first_row_to_display
)
16694 && first_row_to_display
->ends_at_zv_p
16695 && pt_row
== NULL
)))
16696 pt_row
= first_row_to_display
;
16699 /* Start displaying at the start of first_row_to_display. */
16700 eassert (first_row_to_display
->y
< yb
);
16701 init_to_row_start (&it
, w
, first_row_to_display
);
16703 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
16705 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
16707 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
16708 + WINDOW_HEADER_LINE_HEIGHT (w
));
16710 /* Display lines beginning with first_row_to_display in the
16711 desired matrix. Set last_text_row to the last row displayed
16712 that displays text. */
16713 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
16714 if (pt_row
== NULL
)
16715 w
->cursor
.vpos
= -1;
16716 last_text_row
= NULL
;
16717 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
16718 if (display_line (&it
))
16719 last_text_row
= it
.glyph_row
- 1;
16721 /* If point is in a reused row, adjust y and vpos of the cursor
16725 w
->cursor
.vpos
-= nrows_scrolled
;
16726 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
16729 /* Give up if point isn't in a row displayed or reused. (This
16730 also handles the case where w->cursor.vpos < nrows_scrolled
16731 after the calls to display_line, which can happen with scroll
16732 margins. See bug#1295.) */
16733 if (w
->cursor
.vpos
< 0)
16735 clear_glyph_matrix (w
->desired_matrix
);
16739 /* Scroll the display. */
16740 run
.current_y
= first_reusable_row
->y
;
16741 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16742 run
.height
= it
.last_visible_y
- run
.current_y
;
16743 dy
= run
.current_y
- run
.desired_y
;
16748 FRAME_RIF (f
)->update_window_begin_hook (w
);
16749 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16750 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16751 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16755 /* Adjust Y positions of reused rows. */
16756 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
16757 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16758 max_y
= it
.last_visible_y
;
16759 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
16762 row
->visible_height
= row
->height
;
16763 if (row
->y
< min_y
)
16764 row
->visible_height
-= min_y
- row
->y
;
16765 if (row
->y
+ row
->height
> max_y
)
16766 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
16767 if (row
->fringe_bitmap_periodic_p
)
16768 row
->redraw_fringe_bitmaps_p
= 1;
16771 /* Scroll the current matrix. */
16772 eassert (nrows_scrolled
> 0);
16773 rotate_matrix (w
->current_matrix
,
16775 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
16778 /* Disable rows not reused. */
16779 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
16780 row
->enabled_p
= 0;
16782 /* Point may have moved to a different line, so we cannot assume that
16783 the previous cursor position is valid; locate the correct row. */
16786 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
16788 && PT
>= MATRIX_ROW_END_CHARPOS (row
)
16789 && !row
->ends_at_zv_p
;
16793 w
->cursor
.y
= row
->y
;
16795 if (row
< bottom_row
)
16797 /* Can't simply scan the row for point with
16798 bidi-reordered glyph rows. Let set_cursor_from_row
16799 figure out where to put the cursor, and if it fails,
16801 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
16803 if (!set_cursor_from_row (w
, row
, w
->current_matrix
,
16806 clear_glyph_matrix (w
->desired_matrix
);
16812 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
16813 struct glyph
*end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
16816 && (!BUFFERP (glyph
->object
)
16817 || glyph
->charpos
< PT
);
16821 w
->cursor
.x
+= glyph
->pixel_width
;
16827 /* Adjust window end. A null value of last_text_row means that
16828 the window end is in reused rows which in turn means that
16829 only its vpos can have changed. */
16832 w
->window_end_bytepos
16833 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16834 wset_window_end_pos
16835 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16836 wset_window_end_vpos
16837 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
,
16838 w
->desired_matrix
)));
16842 wset_window_end_vpos
16843 (w
, make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
));
16846 wset_window_end_valid (w
, Qnil
);
16847 w
->desired_matrix
->no_scrolling_p
= 1;
16850 debug_method_add (w
, "try_window_reusing_current_matrix 2");
16860 /************************************************************************
16861 Window redisplay reusing current matrix when buffer has changed
16862 ************************************************************************/
16864 static struct glyph_row
*find_last_unchanged_at_beg_row (struct window
*);
16865 static struct glyph_row
*find_first_unchanged_at_end_row (struct window
*,
16866 ptrdiff_t *, ptrdiff_t *);
16867 static struct glyph_row
*
16868 find_last_row_displaying_text (struct glyph_matrix
*, struct it
*,
16869 struct glyph_row
*);
16872 /* Return the last row in MATRIX displaying text. If row START is
16873 non-null, start searching with that row. IT gives the dimensions
16874 of the display. Value is null if matrix is empty; otherwise it is
16875 a pointer to the row found. */
16877 static struct glyph_row
*
16878 find_last_row_displaying_text (struct glyph_matrix
*matrix
, struct it
*it
,
16879 struct glyph_row
*start
)
16881 struct glyph_row
*row
, *row_found
;
16883 /* Set row_found to the last row in IT->w's current matrix
16884 displaying text. The loop looks funny but think of partially
16887 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
16888 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16890 eassert (row
->enabled_p
);
16892 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
16901 /* Return the last row in the current matrix of W that is not affected
16902 by changes at the start of current_buffer that occurred since W's
16903 current matrix was built. Value is null if no such row exists.
16905 BEG_UNCHANGED us the number of characters unchanged at the start of
16906 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
16907 first changed character in current_buffer. Characters at positions <
16908 BEG + BEG_UNCHANGED are at the same buffer positions as they were
16909 when the current matrix was built. */
16911 static struct glyph_row
*
16912 find_last_unchanged_at_beg_row (struct window
*w
)
16914 ptrdiff_t first_changed_pos
= BEG
+ BEG_UNCHANGED
;
16915 struct glyph_row
*row
;
16916 struct glyph_row
*row_found
= NULL
;
16917 int yb
= window_text_bottom_y (w
);
16919 /* Find the last row displaying unchanged text. */
16920 for (row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16921 MATRIX_ROW_DISPLAYS_TEXT_P (row
)
16922 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
;
16925 if (/* If row ends before first_changed_pos, it is unchanged,
16926 except in some case. */
16927 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
16928 /* When row ends in ZV and we write at ZV it is not
16930 && !row
->ends_at_zv_p
16931 /* When first_changed_pos is the end of a continued line,
16932 row is not unchanged because it may be no longer
16934 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
16935 && (row
->continued_p
16936 || row
->exact_window_width_line_p
))
16937 /* If ROW->end is beyond ZV, then ROW->end is outdated and
16938 needs to be recomputed, so don't consider this row as
16939 unchanged. This happens when the last line was
16940 bidi-reordered and was killed immediately before this
16941 redisplay cycle. In that case, ROW->end stores the
16942 buffer position of the first visual-order character of
16943 the killed text, which is now beyond ZV. */
16944 && CHARPOS (row
->end
.pos
) <= ZV
)
16947 /* Stop if last visible row. */
16948 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
16956 /* Find the first glyph row in the current matrix of W that is not
16957 affected by changes at the end of current_buffer since the
16958 time W's current matrix was built.
16960 Return in *DELTA the number of chars by which buffer positions in
16961 unchanged text at the end of current_buffer must be adjusted.
16963 Return in *DELTA_BYTES the corresponding number of bytes.
16965 Value is null if no such row exists, i.e. all rows are affected by
16968 static struct glyph_row
*
16969 find_first_unchanged_at_end_row (struct window
*w
,
16970 ptrdiff_t *delta
, ptrdiff_t *delta_bytes
)
16972 struct glyph_row
*row
;
16973 struct glyph_row
*row_found
= NULL
;
16975 *delta
= *delta_bytes
= 0;
16977 /* Display must not have been paused, otherwise the current matrix
16978 is not up to date. */
16979 eassert (!NILP (w
->window_end_valid
));
16981 /* A value of window_end_pos >= END_UNCHANGED means that the window
16982 end is in the range of changed text. If so, there is no
16983 unchanged row at the end of W's current matrix. */
16984 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
16987 /* Set row to the last row in W's current matrix displaying text. */
16988 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
16990 /* If matrix is entirely empty, no unchanged row exists. */
16991 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16993 /* The value of row is the last glyph row in the matrix having a
16994 meaningful buffer position in it. The end position of row
16995 corresponds to window_end_pos. This allows us to translate
16996 buffer positions in the current matrix to current buffer
16997 positions for characters not in changed text. */
16999 MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
17000 ptrdiff_t Z_BYTE_old
=
17001 MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17002 ptrdiff_t last_unchanged_pos
, last_unchanged_pos_old
;
17003 struct glyph_row
*first_text_row
17004 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
17006 *delta
= Z
- Z_old
;
17007 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17009 /* Set last_unchanged_pos to the buffer position of the last
17010 character in the buffer that has not been changed. Z is the
17011 index + 1 of the last character in current_buffer, i.e. by
17012 subtracting END_UNCHANGED we get the index of the last
17013 unchanged character, and we have to add BEG to get its buffer
17015 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
17016 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
17018 /* Search backward from ROW for a row displaying a line that
17019 starts at a minimum position >= last_unchanged_pos_old. */
17020 for (; row
> first_text_row
; --row
)
17022 /* This used to abort, but it can happen.
17023 It is ok to just stop the search instead here. KFS. */
17024 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17027 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
17032 eassert (!row_found
|| MATRIX_ROW_DISPLAYS_TEXT_P (row_found
));
17038 /* Make sure that glyph rows in the current matrix of window W
17039 reference the same glyph memory as corresponding rows in the
17040 frame's frame matrix. This function is called after scrolling W's
17041 current matrix on a terminal frame in try_window_id and
17042 try_window_reusing_current_matrix. */
17045 sync_frame_with_window_matrix_rows (struct window
*w
)
17047 struct frame
*f
= XFRAME (w
->frame
);
17048 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
17050 /* Preconditions: W must be a leaf window and full-width. Its frame
17051 must have a frame matrix. */
17052 eassert (NILP (w
->hchild
) && NILP (w
->vchild
));
17053 eassert (WINDOW_FULL_WIDTH_P (w
));
17054 eassert (!FRAME_WINDOW_P (f
));
17056 /* If W is a full-width window, glyph pointers in W's current matrix
17057 have, by definition, to be the same as glyph pointers in the
17058 corresponding frame matrix. Note that frame matrices have no
17059 marginal areas (see build_frame_matrix). */
17060 window_row
= w
->current_matrix
->rows
;
17061 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
17062 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
17063 while (window_row
< window_row_end
)
17065 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
17066 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
17068 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
17069 frame_row
->glyphs
[TEXT_AREA
] = start
;
17070 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
17071 frame_row
->glyphs
[LAST_AREA
] = end
;
17073 /* Disable frame rows whose corresponding window rows have
17074 been disabled in try_window_id. */
17075 if (!window_row
->enabled_p
)
17076 frame_row
->enabled_p
= 0;
17078 ++window_row
, ++frame_row
;
17083 /* Find the glyph row in window W containing CHARPOS. Consider all
17084 rows between START and END (not inclusive). END null means search
17085 all rows to the end of the display area of W. Value is the row
17086 containing CHARPOS or null. */
17089 row_containing_pos (struct window
*w
, ptrdiff_t charpos
,
17090 struct glyph_row
*start
, struct glyph_row
*end
, int dy
)
17092 struct glyph_row
*row
= start
;
17093 struct glyph_row
*best_row
= NULL
;
17094 ptrdiff_t mindif
= BUF_ZV (XBUFFER (w
->buffer
)) + 1;
17097 /* If we happen to start on a header-line, skip that. */
17098 if (row
->mode_line_p
)
17101 if ((end
&& row
>= end
) || !row
->enabled_p
)
17104 last_y
= window_text_bottom_y (w
) - dy
;
17108 /* Give up if we have gone too far. */
17109 if (end
&& row
>= end
)
17111 /* This formerly returned if they were equal.
17112 I think that both quantities are of a "last plus one" type;
17113 if so, when they are equal, the row is within the screen. -- rms. */
17114 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
17117 /* If it is in this row, return this row. */
17118 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
17119 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
17120 /* The end position of a row equals the start
17121 position of the next row. If CHARPOS is there, we
17122 would rather display it in the next line, except
17123 when this line ends in ZV. */
17124 && !row
->ends_at_zv_p
17125 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
17126 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
17130 if (NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
17131 || (!best_row
&& !row
->continued_p
))
17133 /* In bidi-reordered rows, there could be several rows
17134 occluding point, all of them belonging to the same
17135 continued line. We need to find the row which fits
17136 CHARPOS the best. */
17137 for (g
= row
->glyphs
[TEXT_AREA
];
17138 g
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
17141 if (!STRINGP (g
->object
))
17143 if (g
->charpos
> 0 && eabs (g
->charpos
- charpos
) < mindif
)
17145 mindif
= eabs (g
->charpos
- charpos
);
17147 /* Exact match always wins. */
17154 else if (best_row
&& !row
->continued_p
)
17161 /* Try to redisplay window W by reusing its existing display. W's
17162 current matrix must be up to date when this function is called,
17163 i.e. window_end_valid must not be nil.
17167 1 if display has been updated
17168 0 if otherwise unsuccessful
17169 -1 if redisplay with same window start is known not to succeed
17171 The following steps are performed:
17173 1. Find the last row in the current matrix of W that is not
17174 affected by changes at the start of current_buffer. If no such row
17177 2. Find the first row in W's current matrix that is not affected by
17178 changes at the end of current_buffer. Maybe there is no such row.
17180 3. Display lines beginning with the row + 1 found in step 1 to the
17181 row found in step 2 or, if step 2 didn't find a row, to the end of
17184 4. If cursor is not known to appear on the window, give up.
17186 5. If display stopped at the row found in step 2, scroll the
17187 display and current matrix as needed.
17189 6. Maybe display some lines at the end of W, if we must. This can
17190 happen under various circumstances, like a partially visible line
17191 becoming fully visible, or because newly displayed lines are displayed
17192 in smaller font sizes.
17194 7. Update W's window end information. */
17197 try_window_id (struct window
*w
)
17199 struct frame
*f
= XFRAME (w
->frame
);
17200 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
17201 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
17202 struct glyph_row
*last_unchanged_at_beg_row
;
17203 struct glyph_row
*first_unchanged_at_end_row
;
17204 struct glyph_row
*row
;
17205 struct glyph_row
*bottom_row
;
17208 ptrdiff_t delta
= 0, delta_bytes
= 0, stop_pos
;
17210 struct text_pos start_pos
;
17212 int first_unchanged_at_end_vpos
= 0;
17213 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
17214 struct text_pos start
;
17215 ptrdiff_t first_changed_charpos
, last_changed_charpos
;
17218 if (inhibit_try_window_id
)
17222 /* This is handy for debugging. */
17224 #define GIVE_UP(X) \
17226 fprintf (stderr, "try_window_id give up %d\n", (X)); \
17230 #define GIVE_UP(X) return 0
17233 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
17235 /* Don't use this for mini-windows because these can show
17236 messages and mini-buffers, and we don't handle that here. */
17237 if (MINI_WINDOW_P (w
))
17240 /* This flag is used to prevent redisplay optimizations. */
17241 if (windows_or_buffers_changed
|| cursor_type_changed
)
17244 /* Verify that narrowing has not changed.
17245 Also verify that we were not told to prevent redisplay optimizations.
17246 It would be nice to further
17247 reduce the number of cases where this prevents try_window_id. */
17248 if (current_buffer
->clip_changed
17249 || current_buffer
->prevent_redisplay_optimizations_p
)
17252 /* Window must either use window-based redisplay or be full width. */
17253 if (!FRAME_WINDOW_P (f
)
17254 && (!FRAME_LINE_INS_DEL_OK (f
)
17255 || !WINDOW_FULL_WIDTH_P (w
)))
17258 /* Give up if point is known NOT to appear in W. */
17259 if (PT
< CHARPOS (start
))
17262 /* Another way to prevent redisplay optimizations. */
17263 if (w
->last_modified
== 0)
17266 /* Verify that window is not hscrolled. */
17267 if (w
->hscroll
!= 0)
17270 /* Verify that display wasn't paused. */
17271 if (NILP (w
->window_end_valid
))
17274 /* Can't use this if highlighting a region because a cursor movement
17275 will do more than just set the cursor. */
17276 if (!NILP (Vtransient_mark_mode
)
17277 && !NILP (BVAR (current_buffer
, mark_active
)))
17280 /* Likewise if highlighting trailing whitespace. */
17281 if (!NILP (Vshow_trailing_whitespace
))
17284 /* Likewise if showing a region. */
17285 if (!NILP (w
->region_showing
))
17288 /* Can't use this if overlay arrow position and/or string have
17290 if (overlay_arrows_changed_p ())
17293 /* When word-wrap is on, adding a space to the first word of a
17294 wrapped line can change the wrap position, altering the line
17295 above it. It might be worthwhile to handle this more
17296 intelligently, but for now just redisplay from scratch. */
17297 if (!NILP (BVAR (XBUFFER (w
->buffer
), word_wrap
)))
17300 /* Under bidi reordering, adding or deleting a character in the
17301 beginning of a paragraph, before the first strong directional
17302 character, can change the base direction of the paragraph (unless
17303 the buffer specifies a fixed paragraph direction), which will
17304 require to redisplay the whole paragraph. It might be worthwhile
17305 to find the paragraph limits and widen the range of redisplayed
17306 lines to that, but for now just give up this optimization and
17307 redisplay from scratch. */
17308 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
17309 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
17312 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
17313 only if buffer has really changed. The reason is that the gap is
17314 initially at Z for freshly visited files. The code below would
17315 set end_unchanged to 0 in that case. */
17316 if (MODIFF
> SAVE_MODIFF
17317 /* This seems to happen sometimes after saving a buffer. */
17318 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
17320 if (GPT
- BEG
< BEG_UNCHANGED
)
17321 BEG_UNCHANGED
= GPT
- BEG
;
17322 if (Z
- GPT
< END_UNCHANGED
)
17323 END_UNCHANGED
= Z
- GPT
;
17326 /* The position of the first and last character that has been changed. */
17327 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
17328 last_changed_charpos
= Z
- END_UNCHANGED
;
17330 /* If window starts after a line end, and the last change is in
17331 front of that newline, then changes don't affect the display.
17332 This case happens with stealth-fontification. Note that although
17333 the display is unchanged, glyph positions in the matrix have to
17334 be adjusted, of course. */
17335 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
17336 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
17337 && ((last_changed_charpos
< CHARPOS (start
)
17338 && CHARPOS (start
) == BEGV
)
17339 || (last_changed_charpos
< CHARPOS (start
) - 1
17340 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
17342 ptrdiff_t Z_old
, Z_delta
, Z_BYTE_old
, Z_delta_bytes
;
17343 struct glyph_row
*r0
;
17345 /* Compute how many chars/bytes have been added to or removed
17346 from the buffer. */
17347 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
17348 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17349 Z_delta
= Z
- Z_old
;
17350 Z_delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17352 /* Give up if PT is not in the window. Note that it already has
17353 been checked at the start of try_window_id that PT is not in
17354 front of the window start. */
17355 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + Z_delta
)
17358 /* If window start is unchanged, we can reuse the whole matrix
17359 as is, after adjusting glyph positions. No need to compute
17360 the window end again, since its offset from Z hasn't changed. */
17361 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17362 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + Z_delta
17363 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + Z_delta_bytes
17364 /* PT must not be in a partially visible line. */
17365 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + Z_delta
17366 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17368 /* Adjust positions in the glyph matrix. */
17369 if (Z_delta
|| Z_delta_bytes
)
17371 struct glyph_row
*r1
17372 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
17373 increment_matrix_positions (w
->current_matrix
,
17374 MATRIX_ROW_VPOS (r0
, current_matrix
),
17375 MATRIX_ROW_VPOS (r1
, current_matrix
),
17376 Z_delta
, Z_delta_bytes
);
17379 /* Set the cursor. */
17380 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17382 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17389 /* Handle the case that changes are all below what is displayed in
17390 the window, and that PT is in the window. This shortcut cannot
17391 be taken if ZV is visible in the window, and text has been added
17392 there that is visible in the window. */
17393 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
17394 /* ZV is not visible in the window, or there are no
17395 changes at ZV, actually. */
17396 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
17397 || first_changed_charpos
== last_changed_charpos
))
17399 struct glyph_row
*r0
;
17401 /* Give up if PT is not in the window. Note that it already has
17402 been checked at the start of try_window_id that PT is not in
17403 front of the window start. */
17404 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
17407 /* If window start is unchanged, we can reuse the whole matrix
17408 as is, without changing glyph positions since no text has
17409 been added/removed in front of the window end. */
17410 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17411 if (TEXT_POS_EQUAL_P (start
, r0
->minpos
)
17412 /* PT must not be in a partially visible line. */
17413 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
17414 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17416 /* We have to compute the window end anew since text
17417 could have been added/removed after it. */
17418 wset_window_end_pos
17419 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17420 w
->window_end_bytepos
17421 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17423 /* Set the cursor. */
17424 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17426 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17433 /* Give up if window start is in the changed area.
17435 The condition used to read
17437 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
17439 but why that was tested escapes me at the moment. */
17440 if (CHARPOS (start
) >= first_changed_charpos
17441 && CHARPOS (start
) <= last_changed_charpos
)
17444 /* Check that window start agrees with the start of the first glyph
17445 row in its current matrix. Check this after we know the window
17446 start is not in changed text, otherwise positions would not be
17448 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17449 if (!TEXT_POS_EQUAL_P (start
, row
->minpos
))
17452 /* Give up if the window ends in strings. Overlay strings
17453 at the end are difficult to handle, so don't try. */
17454 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
17455 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
17458 /* Compute the position at which we have to start displaying new
17459 lines. Some of the lines at the top of the window might be
17460 reusable because they are not displaying changed text. Find the
17461 last row in W's current matrix not affected by changes at the
17462 start of current_buffer. Value is null if changes start in the
17463 first line of window. */
17464 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
17465 if (last_unchanged_at_beg_row
)
17467 /* Avoid starting to display in the middle of a character, a TAB
17468 for instance. This is easier than to set up the iterator
17469 exactly, and it's not a frequent case, so the additional
17470 effort wouldn't really pay off. */
17471 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
17472 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
17473 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
17474 --last_unchanged_at_beg_row
;
17476 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
17479 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
17481 start_pos
= it
.current
.pos
;
17483 /* Start displaying new lines in the desired matrix at the same
17484 vpos we would use in the current matrix, i.e. below
17485 last_unchanged_at_beg_row. */
17486 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
17488 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
17489 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
17491 eassert (it
.hpos
== 0 && it
.current_x
== 0);
17495 /* There are no reusable lines at the start of the window.
17496 Start displaying in the first text line. */
17497 start_display (&it
, w
, start
);
17498 it
.vpos
= it
.first_vpos
;
17499 start_pos
= it
.current
.pos
;
17502 /* Find the first row that is not affected by changes at the end of
17503 the buffer. Value will be null if there is no unchanged row, in
17504 which case we must redisplay to the end of the window. delta
17505 will be set to the value by which buffer positions beginning with
17506 first_unchanged_at_end_row have to be adjusted due to text
17508 first_unchanged_at_end_row
17509 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
17510 IF_DEBUG (debug_delta
= delta
);
17511 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
17513 /* Set stop_pos to the buffer position up to which we will have to
17514 display new lines. If first_unchanged_at_end_row != NULL, this
17515 is the buffer position of the start of the line displayed in that
17516 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
17517 that we don't stop at a buffer position. */
17519 if (first_unchanged_at_end_row
)
17521 eassert (last_unchanged_at_beg_row
== NULL
17522 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
17524 /* If this is a continuation line, move forward to the next one
17525 that isn't. Changes in lines above affect this line.
17526 Caution: this may move first_unchanged_at_end_row to a row
17527 not displaying text. */
17528 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
17529 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17530 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17531 < it
.last_visible_y
))
17532 ++first_unchanged_at_end_row
;
17534 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17535 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17536 >= it
.last_visible_y
))
17537 first_unchanged_at_end_row
= NULL
;
17540 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
17542 first_unchanged_at_end_vpos
17543 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
17544 eassert (stop_pos
>= Z
- END_UNCHANGED
);
17547 else if (last_unchanged_at_beg_row
== NULL
)
17553 /* Either there is no unchanged row at the end, or the one we have
17554 now displays text. This is a necessary condition for the window
17555 end pos calculation at the end of this function. */
17556 eassert (first_unchanged_at_end_row
== NULL
17557 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
17559 debug_last_unchanged_at_beg_vpos
17560 = (last_unchanged_at_beg_row
17561 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
17563 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
17565 #endif /* GLYPH_DEBUG */
17568 /* Display new lines. Set last_text_row to the last new line
17569 displayed which has text on it, i.e. might end up as being the
17570 line where the window_end_vpos is. */
17571 w
->cursor
.vpos
= -1;
17572 last_text_row
= NULL
;
17573 overlay_arrow_seen
= 0;
17574 while (it
.current_y
< it
.last_visible_y
17575 && !fonts_changed_p
17576 && (first_unchanged_at_end_row
== NULL
17577 || IT_CHARPOS (it
) < stop_pos
))
17579 if (display_line (&it
))
17580 last_text_row
= it
.glyph_row
- 1;
17583 if (fonts_changed_p
)
17587 /* Compute differences in buffer positions, y-positions etc. for
17588 lines reused at the bottom of the window. Compute what we can
17590 if (first_unchanged_at_end_row
17591 /* No lines reused because we displayed everything up to the
17592 bottom of the window. */
17593 && it
.current_y
< it
.last_visible_y
)
17596 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
17598 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
17599 run
.current_y
= first_unchanged_at_end_row
->y
;
17600 run
.desired_y
= run
.current_y
+ dy
;
17601 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
17605 delta
= delta_bytes
= dvpos
= dy
17606 = run
.current_y
= run
.desired_y
= run
.height
= 0;
17607 first_unchanged_at_end_row
= NULL
;
17609 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
17612 /* Find the cursor if not already found. We have to decide whether
17613 PT will appear on this window (it sometimes doesn't, but this is
17614 not a very frequent case.) This decision has to be made before
17615 the current matrix is altered. A value of cursor.vpos < 0 means
17616 that PT is either in one of the lines beginning at
17617 first_unchanged_at_end_row or below the window. Don't care for
17618 lines that might be displayed later at the window end; as
17619 mentioned, this is not a frequent case. */
17620 if (w
->cursor
.vpos
< 0)
17622 /* Cursor in unchanged rows at the top? */
17623 if (PT
< CHARPOS (start_pos
)
17624 && last_unchanged_at_beg_row
)
17626 row
= row_containing_pos (w
, PT
,
17627 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
17628 last_unchanged_at_beg_row
+ 1, 0);
17630 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
17633 /* Start from first_unchanged_at_end_row looking for PT. */
17634 else if (first_unchanged_at_end_row
)
17636 row
= row_containing_pos (w
, PT
- delta
,
17637 first_unchanged_at_end_row
, NULL
, 0);
17639 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
17640 delta_bytes
, dy
, dvpos
);
17643 /* Give up if cursor was not found. */
17644 if (w
->cursor
.vpos
< 0)
17646 clear_glyph_matrix (w
->desired_matrix
);
17651 /* Don't let the cursor end in the scroll margins. */
17653 int this_scroll_margin
, cursor_height
;
17655 this_scroll_margin
=
17656 max (0, min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4));
17657 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
17658 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
17660 if ((w
->cursor
.y
< this_scroll_margin
17661 && CHARPOS (start
) > BEGV
)
17662 /* Old redisplay didn't take scroll margin into account at the bottom,
17663 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
17664 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
17665 ? cursor_height
+ this_scroll_margin
17666 : 1)) > it
.last_visible_y
)
17668 w
->cursor
.vpos
= -1;
17669 clear_glyph_matrix (w
->desired_matrix
);
17674 /* Scroll the display. Do it before changing the current matrix so
17675 that xterm.c doesn't get confused about where the cursor glyph is
17677 if (dy
&& run
.height
)
17681 if (FRAME_WINDOW_P (f
))
17683 FRAME_RIF (f
)->update_window_begin_hook (w
);
17684 FRAME_RIF (f
)->clear_window_mouse_face (w
);
17685 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
17686 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
17690 /* Terminal frame. In this case, dvpos gives the number of
17691 lines to scroll by; dvpos < 0 means scroll up. */
17693 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
17694 int from
= WINDOW_TOP_EDGE_LINE (w
) + from_vpos
;
17695 int end
= (WINDOW_TOP_EDGE_LINE (w
)
17696 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
17697 + window_internal_height (w
));
17699 #if defined (HAVE_GPM) || defined (MSDOS)
17700 x_clear_window_mouse_face (w
);
17702 /* Perform the operation on the screen. */
17705 /* Scroll last_unchanged_at_beg_row to the end of the
17706 window down dvpos lines. */
17707 set_terminal_window (f
, end
);
17709 /* On dumb terminals delete dvpos lines at the end
17710 before inserting dvpos empty lines. */
17711 if (!FRAME_SCROLL_REGION_OK (f
))
17712 ins_del_lines (f
, end
- dvpos
, -dvpos
);
17714 /* Insert dvpos empty lines in front of
17715 last_unchanged_at_beg_row. */
17716 ins_del_lines (f
, from
, dvpos
);
17718 else if (dvpos
< 0)
17720 /* Scroll up last_unchanged_at_beg_vpos to the end of
17721 the window to last_unchanged_at_beg_vpos - |dvpos|. */
17722 set_terminal_window (f
, end
);
17724 /* Delete dvpos lines in front of
17725 last_unchanged_at_beg_vpos. ins_del_lines will set
17726 the cursor to the given vpos and emit |dvpos| delete
17728 ins_del_lines (f
, from
+ dvpos
, dvpos
);
17730 /* On a dumb terminal insert dvpos empty lines at the
17732 if (!FRAME_SCROLL_REGION_OK (f
))
17733 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
17736 set_terminal_window (f
, 0);
17742 /* Shift reused rows of the current matrix to the right position.
17743 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
17745 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
17746 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
17749 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
17750 bottom_vpos
, dvpos
);
17751 clear_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
17754 else if (dvpos
> 0)
17756 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
17757 bottom_vpos
, dvpos
);
17758 clear_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
17759 first_unchanged_at_end_vpos
+ dvpos
);
17762 /* For frame-based redisplay, make sure that current frame and window
17763 matrix are in sync with respect to glyph memory. */
17764 if (!FRAME_WINDOW_P (f
))
17765 sync_frame_with_window_matrix_rows (w
);
17767 /* Adjust buffer positions in reused rows. */
17768 if (delta
|| delta_bytes
)
17769 increment_matrix_positions (current_matrix
,
17770 first_unchanged_at_end_vpos
+ dvpos
,
17771 bottom_vpos
, delta
, delta_bytes
);
17773 /* Adjust Y positions. */
17775 shift_glyph_matrix (w
, current_matrix
,
17776 first_unchanged_at_end_vpos
+ dvpos
,
17779 if (first_unchanged_at_end_row
)
17781 first_unchanged_at_end_row
+= dvpos
;
17782 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
17783 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
17784 first_unchanged_at_end_row
= NULL
;
17787 /* If scrolling up, there may be some lines to display at the end of
17789 last_text_row_at_end
= NULL
;
17792 /* Scrolling up can leave for example a partially visible line
17793 at the end of the window to be redisplayed. */
17794 /* Set last_row to the glyph row in the current matrix where the
17795 window end line is found. It has been moved up or down in
17796 the matrix by dvpos. */
17797 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
17798 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
17800 /* If last_row is the window end line, it should display text. */
17801 eassert (last_row
->displays_text_p
);
17803 /* If window end line was partially visible before, begin
17804 displaying at that line. Otherwise begin displaying with the
17805 line following it. */
17806 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
17808 init_to_row_start (&it
, w
, last_row
);
17809 it
.vpos
= last_vpos
;
17810 it
.current_y
= last_row
->y
;
17814 init_to_row_end (&it
, w
, last_row
);
17815 it
.vpos
= 1 + last_vpos
;
17816 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
17820 /* We may start in a continuation line. If so, we have to
17821 get the right continuation_lines_width and current_x. */
17822 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
17823 it
.hpos
= it
.current_x
= 0;
17825 /* Display the rest of the lines at the window end. */
17826 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
17827 while (it
.current_y
< it
.last_visible_y
17828 && !fonts_changed_p
)
17830 /* Is it always sure that the display agrees with lines in
17831 the current matrix? I don't think so, so we mark rows
17832 displayed invalid in the current matrix by setting their
17833 enabled_p flag to zero. */
17834 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
17835 if (display_line (&it
))
17836 last_text_row_at_end
= it
.glyph_row
- 1;
17840 /* Update window_end_pos and window_end_vpos. */
17841 if (first_unchanged_at_end_row
17842 && !last_text_row_at_end
)
17844 /* Window end line if one of the preserved rows from the current
17845 matrix. Set row to the last row displaying text in current
17846 matrix starting at first_unchanged_at_end_row, after
17848 eassert (first_unchanged_at_end_row
->displays_text_p
);
17849 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
17850 first_unchanged_at_end_row
);
17851 eassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
17853 wset_window_end_pos (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17854 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17855 wset_window_end_vpos
17856 (w
, make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
)));
17857 eassert (w
->window_end_bytepos
>= 0);
17858 IF_DEBUG (debug_method_add (w
, "A"));
17860 else if (last_text_row_at_end
)
17862 wset_window_end_pos
17863 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
)));
17864 w
->window_end_bytepos
17865 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
17866 wset_window_end_vpos
17867 (w
, make_number (MATRIX_ROW_VPOS (last_text_row_at_end
,
17869 eassert (w
->window_end_bytepos
>= 0);
17870 IF_DEBUG (debug_method_add (w
, "B"));
17872 else if (last_text_row
)
17874 /* We have displayed either to the end of the window or at the
17875 end of the window, i.e. the last row with text is to be found
17876 in the desired matrix. */
17877 wset_window_end_pos
17878 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
17879 w
->window_end_bytepos
17880 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
17881 wset_window_end_vpos
17882 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
)));
17883 eassert (w
->window_end_bytepos
>= 0);
17885 else if (first_unchanged_at_end_row
== NULL
17886 && last_text_row
== NULL
17887 && last_text_row_at_end
== NULL
)
17889 /* Displayed to end of window, but no line containing text was
17890 displayed. Lines were deleted at the end of the window. */
17891 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
17892 int vpos
= XFASTINT (w
->window_end_vpos
);
17893 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
17894 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
17897 row
== NULL
&& vpos
>= first_vpos
;
17898 --vpos
, --current_row
, --desired_row
)
17900 if (desired_row
->enabled_p
)
17902 if (desired_row
->displays_text_p
)
17905 else if (current_row
->displays_text_p
)
17909 eassert (row
!= NULL
);
17910 wset_window_end_vpos (w
, make_number (vpos
+ 1));
17911 wset_window_end_pos (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17912 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17913 eassert (w
->window_end_bytepos
>= 0);
17914 IF_DEBUG (debug_method_add (w
, "C"));
17919 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
17920 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
17922 /* Record that display has not been completed. */
17923 wset_window_end_valid (w
, Qnil
);
17924 w
->desired_matrix
->no_scrolling_p
= 1;
17932 /***********************************************************************
17933 More debugging support
17934 ***********************************************************************/
17938 void dump_glyph_row (struct glyph_row
*, int, int) EXTERNALLY_VISIBLE
;
17939 void dump_glyph_matrix (struct glyph_matrix
*, int) EXTERNALLY_VISIBLE
;
17940 void dump_glyph (struct glyph_row
*, struct glyph
*, int) EXTERNALLY_VISIBLE
;
17943 /* Dump the contents of glyph matrix MATRIX on stderr.
17945 GLYPHS 0 means don't show glyph contents.
17946 GLYPHS 1 means show glyphs in short form
17947 GLYPHS > 1 means show glyphs in long form. */
17950 dump_glyph_matrix (struct glyph_matrix
*matrix
, int glyphs
)
17953 for (i
= 0; i
< matrix
->nrows
; ++i
)
17954 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
17958 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
17959 the glyph row and area where the glyph comes from. */
17962 dump_glyph (struct glyph_row
*row
, struct glyph
*glyph
, int area
)
17964 if (glyph
->type
== CHAR_GLYPH
)
17967 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17968 glyph
- row
->glyphs
[TEXT_AREA
],
17971 (BUFFERP (glyph
->object
)
17973 : (STRINGP (glyph
->object
)
17976 glyph
->pixel_width
,
17978 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
17982 glyph
->left_box_line_p
,
17983 glyph
->right_box_line_p
);
17985 else if (glyph
->type
== STRETCH_GLYPH
)
17988 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17989 glyph
- row
->glyphs
[TEXT_AREA
],
17992 (BUFFERP (glyph
->object
)
17994 : (STRINGP (glyph
->object
)
17997 glyph
->pixel_width
,
18001 glyph
->left_box_line_p
,
18002 glyph
->right_box_line_p
);
18004 else if (glyph
->type
== IMAGE_GLYPH
)
18007 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
18008 glyph
- row
->glyphs
[TEXT_AREA
],
18011 (BUFFERP (glyph
->object
)
18013 : (STRINGP (glyph
->object
)
18016 glyph
->pixel_width
,
18020 glyph
->left_box_line_p
,
18021 glyph
->right_box_line_p
);
18023 else if (glyph
->type
== COMPOSITE_GLYPH
)
18026 " %5td %4c %6"pI
"d %c %3d 0x%05x",
18027 glyph
- row
->glyphs
[TEXT_AREA
],
18030 (BUFFERP (glyph
->object
)
18032 : (STRINGP (glyph
->object
)
18035 glyph
->pixel_width
,
18037 if (glyph
->u
.cmp
.automatic
)
18040 glyph
->slice
.cmp
.from
, glyph
->slice
.cmp
.to
);
18041 fprintf (stderr
, " . %4d %1.1d%1.1d\n",
18043 glyph
->left_box_line_p
,
18044 glyph
->right_box_line_p
);
18049 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
18050 GLYPHS 0 means don't show glyph contents.
18051 GLYPHS 1 means show glyphs in short form
18052 GLYPHS > 1 means show glyphs in long form. */
18055 dump_glyph_row (struct glyph_row
*row
, int vpos
, int glyphs
)
18059 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
18060 fprintf (stderr
, "======================================================================\n");
18062 fprintf (stderr
, "%3d %5"pI
"d %5"pI
"d %4d %1.1d%1.1d%1.1d%1.1d\
18063 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
18065 MATRIX_ROW_START_CHARPOS (row
),
18066 MATRIX_ROW_END_CHARPOS (row
),
18067 row
->used
[TEXT_AREA
],
18068 row
->contains_overlapping_glyphs_p
,
18070 row
->truncated_on_left_p
,
18071 row
->truncated_on_right_p
,
18073 MATRIX_ROW_CONTINUATION_LINE_P (row
),
18074 row
->displays_text_p
,
18077 row
->ends_in_middle_of_char_p
,
18078 row
->starts_in_middle_of_char_p
,
18084 row
->visible_height
,
18087 fprintf (stderr
, "%9"pD
"d %5"pD
"d\t%5d\n", row
->start
.overlay_string_index
,
18088 row
->end
.overlay_string_index
,
18089 row
->continuation_lines_width
);
18090 fprintf (stderr
, "%9"pI
"d %5"pI
"d\n",
18091 CHARPOS (row
->start
.string_pos
),
18092 CHARPOS (row
->end
.string_pos
));
18093 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
18094 row
->end
.dpvec_index
);
18101 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18103 struct glyph
*glyph
= row
->glyphs
[area
];
18104 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
18106 /* Glyph for a line end in text. */
18107 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
18110 if (glyph
< glyph_end
)
18111 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
18113 for (; glyph
< glyph_end
; ++glyph
)
18114 dump_glyph (row
, glyph
, area
);
18117 else if (glyphs
== 1)
18121 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18123 char *s
= alloca (row
->used
[area
] + 1);
18126 for (i
= 0; i
< row
->used
[area
]; ++i
)
18128 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
18129 if (glyph
->type
== CHAR_GLYPH
18130 && glyph
->u
.ch
< 0x80
18131 && glyph
->u
.ch
>= ' ')
18132 s
[i
] = glyph
->u
.ch
;
18138 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
18144 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
18145 Sdump_glyph_matrix
, 0, 1, "p",
18146 doc
: /* Dump the current matrix of the selected window to stderr.
18147 Shows contents of glyph row structures. With non-nil
18148 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
18149 glyphs in short form, otherwise show glyphs in long form. */)
18150 (Lisp_Object glyphs
)
18152 struct window
*w
= XWINDOW (selected_window
);
18153 struct buffer
*buffer
= XBUFFER (w
->buffer
);
18155 fprintf (stderr
, "PT = %"pI
"d, BEGV = %"pI
"d. ZV = %"pI
"d\n",
18156 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
18157 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
18158 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
18159 fprintf (stderr
, "=============================================\n");
18160 dump_glyph_matrix (w
->current_matrix
,
18161 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 0);
18166 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
18167 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
18170 struct frame
*f
= XFRAME (selected_frame
);
18171 dump_glyph_matrix (f
->current_matrix
, 1);
18176 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
18177 doc
: /* Dump glyph row ROW to stderr.
18178 GLYPH 0 means don't dump glyphs.
18179 GLYPH 1 means dump glyphs in short form.
18180 GLYPH > 1 or omitted means dump glyphs in long form. */)
18181 (Lisp_Object row
, Lisp_Object glyphs
)
18183 struct glyph_matrix
*matrix
;
18186 CHECK_NUMBER (row
);
18187 matrix
= XWINDOW (selected_window
)->current_matrix
;
18189 if (vpos
>= 0 && vpos
< matrix
->nrows
)
18190 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
18192 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18197 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
18198 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
18199 GLYPH 0 means don't dump glyphs.
18200 GLYPH 1 means dump glyphs in short form.
18201 GLYPH > 1 or omitted means dump glyphs in long form. */)
18202 (Lisp_Object row
, Lisp_Object glyphs
)
18204 struct frame
*sf
= SELECTED_FRAME ();
18205 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
18208 CHECK_NUMBER (row
);
18210 if (vpos
>= 0 && vpos
< m
->nrows
)
18211 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
18212 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18217 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
18218 doc
: /* Toggle tracing of redisplay.
18219 With ARG, turn tracing on if and only if ARG is positive. */)
18223 trace_redisplay_p
= !trace_redisplay_p
;
18226 arg
= Fprefix_numeric_value (arg
);
18227 trace_redisplay_p
= XINT (arg
) > 0;
18234 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
18235 doc
: /* Like `format', but print result to stderr.
18236 usage: (trace-to-stderr STRING &rest OBJECTS) */)
18237 (ptrdiff_t nargs
, Lisp_Object
*args
)
18239 Lisp_Object s
= Fformat (nargs
, args
);
18240 fprintf (stderr
, "%s", SDATA (s
));
18244 #endif /* GLYPH_DEBUG */
18248 /***********************************************************************
18249 Building Desired Matrix Rows
18250 ***********************************************************************/
18252 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
18253 Used for non-window-redisplay windows, and for windows w/o left fringe. */
18255 static struct glyph_row
*
18256 get_overlay_arrow_glyph_row (struct window
*w
, Lisp_Object overlay_arrow_string
)
18258 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
18259 struct buffer
*buffer
= XBUFFER (w
->buffer
);
18260 struct buffer
*old
= current_buffer
;
18261 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
18262 int arrow_len
= SCHARS (overlay_arrow_string
);
18263 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
18264 const unsigned char *p
;
18267 int n_glyphs_before
;
18269 set_buffer_temp (buffer
);
18270 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
18271 it
.glyph_row
->used
[TEXT_AREA
] = 0;
18272 SET_TEXT_POS (it
.position
, 0, 0);
18274 multibyte_p
= !NILP (BVAR (buffer
, enable_multibyte_characters
));
18276 while (p
< arrow_end
)
18278 Lisp_Object face
, ilisp
;
18280 /* Get the next character. */
18282 it
.c
= it
.char_to_display
= string_char_and_length (p
, &it
.len
);
18285 it
.c
= it
.char_to_display
= *p
, it
.len
= 1;
18286 if (! ASCII_CHAR_P (it
.c
))
18287 it
.char_to_display
= BYTE8_TO_CHAR (it
.c
);
18291 /* Get its face. */
18292 ilisp
= make_number (p
- arrow_string
);
18293 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
18294 it
.face_id
= compute_char_face (f
, it
.char_to_display
, face
);
18296 /* Compute its width, get its glyphs. */
18297 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
18298 SET_TEXT_POS (it
.position
, -1, -1);
18299 PRODUCE_GLYPHS (&it
);
18301 /* If this character doesn't fit any more in the line, we have
18302 to remove some glyphs. */
18303 if (it
.current_x
> it
.last_visible_x
)
18305 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
18310 set_buffer_temp (old
);
18311 return it
.glyph_row
;
18315 /* Insert truncation glyphs at the start of IT->glyph_row. Which
18316 glyphs to insert is determined by produce_special_glyphs. */
18319 insert_left_trunc_glyphs (struct it
*it
)
18321 struct it truncate_it
;
18322 struct glyph
*from
, *end
, *to
, *toend
;
18324 eassert (!FRAME_WINDOW_P (it
->f
)
18325 || (!it
->glyph_row
->reversed_p
18326 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0)
18327 || (it
->glyph_row
->reversed_p
18328 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0));
18330 /* Get the truncation glyphs. */
18332 truncate_it
.current_x
= 0;
18333 truncate_it
.face_id
= DEFAULT_FACE_ID
;
18334 truncate_it
.glyph_row
= &scratch_glyph_row
;
18335 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
18336 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
18337 truncate_it
.object
= make_number (0);
18338 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
18340 /* Overwrite glyphs from IT with truncation glyphs. */
18341 if (!it
->glyph_row
->reversed_p
)
18343 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18345 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18346 end
= from
+ tused
;
18347 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18348 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
18349 if (FRAME_WINDOW_P (it
->f
))
18351 /* On GUI frames, when variable-size fonts are displayed,
18352 the truncation glyphs may need more pixels than the row's
18353 glyphs they overwrite. We overwrite more glyphs to free
18354 enough screen real estate, and enlarge the stretch glyph
18355 on the right (see display_line), if there is one, to
18356 preserve the screen position of the truncation glyphs on
18359 struct glyph
*g
= to
;
18362 /* The first glyph could be partially visible, in which case
18363 it->glyph_row->x will be negative. But we want the left
18364 truncation glyphs to be aligned at the left margin of the
18365 window, so we override the x coordinate at which the row
18367 it
->glyph_row
->x
= 0;
18368 while (g
< toend
&& w
< it
->truncation_pixel_width
)
18370 w
+= g
->pixel_width
;
18373 if (g
- to
- tused
> 0)
18375 memmove (to
+ tused
, g
, (toend
- g
) * sizeof(*g
));
18376 it
->glyph_row
->used
[TEXT_AREA
] -= g
- to
- tused
;
18378 used
= it
->glyph_row
->used
[TEXT_AREA
];
18379 if (it
->glyph_row
->truncated_on_right_p
18380 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
18381 && it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].type
18384 int extra
= w
- it
->truncation_pixel_width
;
18386 it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].pixel_width
+= extra
;
18393 /* There may be padding glyphs left over. Overwrite them too. */
18394 if (!FRAME_WINDOW_P (it
->f
))
18396 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
18398 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18405 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
18409 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18411 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
18412 that back to front. */
18413 end
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18414 from
= end
+ truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18415 toend
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18416 to
= toend
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18417 if (FRAME_WINDOW_P (it
->f
))
18420 struct glyph
*g
= to
;
18422 while (g
>= toend
&& w
< it
->truncation_pixel_width
)
18424 w
+= g
->pixel_width
;
18427 if (to
- g
- tused
> 0)
18429 if (it
->glyph_row
->truncated_on_right_p
18430 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0
18431 && it
->glyph_row
->glyphs
[TEXT_AREA
][1].type
== STRETCH_GLYPH
)
18433 int extra
= w
- it
->truncation_pixel_width
;
18435 it
->glyph_row
->glyphs
[TEXT_AREA
][1].pixel_width
+= extra
;
18439 while (from
>= end
&& to
>= toend
)
18441 if (!FRAME_WINDOW_P (it
->f
))
18443 while (to
>= toend
&& CHAR_GLYPH_PADDING_P (*to
))
18446 truncate_it
.glyph_row
->glyphs
[TEXT_AREA
]
18447 + truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18448 while (from
>= end
&& to
>= toend
)
18454 /* Need to free some room before prepending additional
18456 int move_by
= from
- end
+ 1;
18457 struct glyph
*g0
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18458 struct glyph
*g
= g0
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18460 for ( ; g
>= g0
; g
--)
18462 while (from
>= end
)
18464 it
->glyph_row
->used
[TEXT_AREA
] += move_by
;
18469 /* Compute the hash code for ROW. */
18471 row_hash (struct glyph_row
*row
)
18474 unsigned hashval
= 0;
18476 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18477 for (k
= 0; k
< row
->used
[area
]; ++k
)
18478 hashval
= ((((hashval
<< 4) + (hashval
>> 24)) & 0x0fffffff)
18479 + row
->glyphs
[area
][k
].u
.val
18480 + row
->glyphs
[area
][k
].face_id
18481 + row
->glyphs
[area
][k
].padding_p
18482 + (row
->glyphs
[area
][k
].type
<< 2));
18487 /* Compute the pixel height and width of IT->glyph_row.
18489 Most of the time, ascent and height of a display line will be equal
18490 to the max_ascent and max_height values of the display iterator
18491 structure. This is not the case if
18493 1. We hit ZV without displaying anything. In this case, max_ascent
18494 and max_height will be zero.
18496 2. We have some glyphs that don't contribute to the line height.
18497 (The glyph row flag contributes_to_line_height_p is for future
18498 pixmap extensions).
18500 The first case is easily covered by using default values because in
18501 these cases, the line height does not really matter, except that it
18502 must not be zero. */
18505 compute_line_metrics (struct it
*it
)
18507 struct glyph_row
*row
= it
->glyph_row
;
18509 if (FRAME_WINDOW_P (it
->f
))
18511 int i
, min_y
, max_y
;
18513 /* The line may consist of one space only, that was added to
18514 place the cursor on it. If so, the row's height hasn't been
18516 if (row
->height
== 0)
18518 if (it
->max_ascent
+ it
->max_descent
== 0)
18519 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
18520 row
->ascent
= it
->max_ascent
;
18521 row
->height
= it
->max_ascent
+ it
->max_descent
;
18522 row
->phys_ascent
= it
->max_phys_ascent
;
18523 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
18524 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
18527 /* Compute the width of this line. */
18528 row
->pixel_width
= row
->x
;
18529 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
18530 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
18532 eassert (row
->pixel_width
>= 0);
18533 eassert (row
->ascent
>= 0 && row
->height
> 0);
18535 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
18536 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
18538 /* If first line's physical ascent is larger than its logical
18539 ascent, use the physical ascent, and make the row taller.
18540 This makes accented characters fully visible. */
18541 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
18542 && row
->phys_ascent
> row
->ascent
)
18544 row
->height
+= row
->phys_ascent
- row
->ascent
;
18545 row
->ascent
= row
->phys_ascent
;
18548 /* Compute how much of the line is visible. */
18549 row
->visible_height
= row
->height
;
18551 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
18552 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
18554 if (row
->y
< min_y
)
18555 row
->visible_height
-= min_y
- row
->y
;
18556 if (row
->y
+ row
->height
> max_y
)
18557 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
18561 row
->pixel_width
= row
->used
[TEXT_AREA
];
18562 if (row
->continued_p
)
18563 row
->pixel_width
-= it
->continuation_pixel_width
;
18564 else if (row
->truncated_on_right_p
)
18565 row
->pixel_width
-= it
->truncation_pixel_width
;
18566 row
->ascent
= row
->phys_ascent
= 0;
18567 row
->height
= row
->phys_height
= row
->visible_height
= 1;
18568 row
->extra_line_spacing
= 0;
18571 /* Compute a hash code for this row. */
18572 row
->hash
= row_hash (row
);
18574 it
->max_ascent
= it
->max_descent
= 0;
18575 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
18579 /* Append one space to the glyph row of iterator IT if doing a
18580 window-based redisplay. The space has the same face as
18581 IT->face_id. Value is non-zero if a space was added.
18583 This function is called to make sure that there is always one glyph
18584 at the end of a glyph row that the cursor can be set on under
18585 window-systems. (If there weren't such a glyph we would not know
18586 how wide and tall a box cursor should be displayed).
18588 At the same time this space let's a nicely handle clearing to the
18589 end of the line if the row ends in italic text. */
18592 append_space_for_newline (struct it
*it
, int default_face_p
)
18594 if (FRAME_WINDOW_P (it
->f
))
18596 int n
= it
->glyph_row
->used
[TEXT_AREA
];
18598 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
18599 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
18601 /* Save some values that must not be changed.
18602 Must save IT->c and IT->len because otherwise
18603 ITERATOR_AT_END_P wouldn't work anymore after
18604 append_space_for_newline has been called. */
18605 enum display_element_type saved_what
= it
->what
;
18606 int saved_c
= it
->c
, saved_len
= it
->len
;
18607 int saved_char_to_display
= it
->char_to_display
;
18608 int saved_x
= it
->current_x
;
18609 int saved_face_id
= it
->face_id
;
18610 struct text_pos saved_pos
;
18611 Lisp_Object saved_object
;
18614 saved_object
= it
->object
;
18615 saved_pos
= it
->position
;
18617 it
->what
= IT_CHARACTER
;
18618 memset (&it
->position
, 0, sizeof it
->position
);
18619 it
->object
= make_number (0);
18620 it
->c
= it
->char_to_display
= ' ';
18623 /* If the default face was remapped, be sure to use the
18624 remapped face for the appended newline. */
18625 if (default_face_p
)
18626 it
->face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);
18627 else if (it
->face_before_selective_p
)
18628 it
->face_id
= it
->saved_face_id
;
18629 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
18630 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
18632 PRODUCE_GLYPHS (it
);
18634 it
->override_ascent
= -1;
18635 it
->constrain_row_ascent_descent_p
= 0;
18636 it
->current_x
= saved_x
;
18637 it
->object
= saved_object
;
18638 it
->position
= saved_pos
;
18639 it
->what
= saved_what
;
18640 it
->face_id
= saved_face_id
;
18641 it
->len
= saved_len
;
18643 it
->char_to_display
= saved_char_to_display
;
18652 /* Extend the face of the last glyph in the text area of IT->glyph_row
18653 to the end of the display line. Called from display_line. If the
18654 glyph row is empty, add a space glyph to it so that we know the
18655 face to draw. Set the glyph row flag fill_line_p. If the glyph
18656 row is R2L, prepend a stretch glyph to cover the empty space to the
18657 left of the leftmost glyph. */
18660 extend_face_to_end_of_line (struct it
*it
)
18662 struct face
*face
, *default_face
;
18663 struct frame
*f
= it
->f
;
18665 /* If line is already filled, do nothing. Non window-system frames
18666 get a grace of one more ``pixel'' because their characters are
18667 1-``pixel'' wide, so they hit the equality too early. This grace
18668 is needed only for R2L rows that are not continued, to produce
18669 one extra blank where we could display the cursor. */
18670 if (it
->current_x
>= it
->last_visible_x
18671 + (!FRAME_WINDOW_P (f
)
18672 && it
->glyph_row
->reversed_p
18673 && !it
->glyph_row
->continued_p
))
18676 /* The default face, possibly remapped. */
18677 default_face
= FACE_FROM_ID (f
, lookup_basic_face (f
, DEFAULT_FACE_ID
));
18679 /* Face extension extends the background and box of IT->face_id
18680 to the end of the line. If the background equals the background
18681 of the frame, we don't have to do anything. */
18682 if (it
->face_before_selective_p
)
18683 face
= FACE_FROM_ID (f
, it
->saved_face_id
);
18685 face
= FACE_FROM_ID (f
, it
->face_id
);
18687 if (FRAME_WINDOW_P (f
)
18688 && it
->glyph_row
->displays_text_p
18689 && face
->box
== FACE_NO_BOX
18690 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
18692 && !it
->glyph_row
->reversed_p
)
18695 /* Set the glyph row flag indicating that the face of the last glyph
18696 in the text area has to be drawn to the end of the text area. */
18697 it
->glyph_row
->fill_line_p
= 1;
18699 /* If current character of IT is not ASCII, make sure we have the
18700 ASCII face. This will be automatically undone the next time
18701 get_next_display_element returns a multibyte character. Note
18702 that the character will always be single byte in unibyte
18704 if (!ASCII_CHAR_P (it
->c
))
18706 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
18709 if (FRAME_WINDOW_P (f
))
18711 /* If the row is empty, add a space with the current face of IT,
18712 so that we know which face to draw. */
18713 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
18715 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
18716 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= face
->id
;
18717 it
->glyph_row
->used
[TEXT_AREA
] = 1;
18719 #ifdef HAVE_WINDOW_SYSTEM
18720 if (it
->glyph_row
->reversed_p
)
18722 /* Prepend a stretch glyph to the row, such that the
18723 rightmost glyph will be drawn flushed all the way to the
18724 right margin of the window. The stretch glyph that will
18725 occupy the empty space, if any, to the left of the
18727 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (f
);
18728 struct glyph
*row_start
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18729 struct glyph
*row_end
= row_start
+ it
->glyph_row
->used
[TEXT_AREA
];
18731 int row_width
, stretch_ascent
, stretch_width
;
18732 struct text_pos saved_pos
;
18733 int saved_face_id
, saved_avoid_cursor
;
18735 for (row_width
= 0, g
= row_start
; g
< row_end
; g
++)
18736 row_width
+= g
->pixel_width
;
18737 stretch_width
= window_box_width (it
->w
, TEXT_AREA
) - row_width
;
18738 if (stretch_width
> 0)
18741 (((it
->ascent
+ it
->descent
)
18742 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
18743 saved_pos
= it
->position
;
18744 memset (&it
->position
, 0, sizeof it
->position
);
18745 saved_avoid_cursor
= it
->avoid_cursor_p
;
18746 it
->avoid_cursor_p
= 1;
18747 saved_face_id
= it
->face_id
;
18748 /* The last row's stretch glyph should get the default
18749 face, to avoid painting the rest of the window with
18750 the region face, if the region ends at ZV. */
18751 if (it
->glyph_row
->ends_at_zv_p
)
18752 it
->face_id
= default_face
->id
;
18754 it
->face_id
= face
->id
;
18755 append_stretch_glyph (it
, make_number (0), stretch_width
,
18756 it
->ascent
+ it
->descent
, stretch_ascent
);
18757 it
->position
= saved_pos
;
18758 it
->avoid_cursor_p
= saved_avoid_cursor
;
18759 it
->face_id
= saved_face_id
;
18762 #endif /* HAVE_WINDOW_SYSTEM */
18766 /* Save some values that must not be changed. */
18767 int saved_x
= it
->current_x
;
18768 struct text_pos saved_pos
;
18769 Lisp_Object saved_object
;
18770 enum display_element_type saved_what
= it
->what
;
18771 int saved_face_id
= it
->face_id
;
18773 saved_object
= it
->object
;
18774 saved_pos
= it
->position
;
18776 it
->what
= IT_CHARACTER
;
18777 memset (&it
->position
, 0, sizeof it
->position
);
18778 it
->object
= make_number (0);
18779 it
->c
= it
->char_to_display
= ' ';
18781 /* The last row's blank glyphs should get the default face, to
18782 avoid painting the rest of the window with the region face,
18783 if the region ends at ZV. */
18784 if (it
->glyph_row
->ends_at_zv_p
)
18785 it
->face_id
= default_face
->id
;
18787 it
->face_id
= face
->id
;
18789 PRODUCE_GLYPHS (it
);
18791 while (it
->current_x
<= it
->last_visible_x
)
18792 PRODUCE_GLYPHS (it
);
18794 /* Don't count these blanks really. It would let us insert a left
18795 truncation glyph below and make us set the cursor on them, maybe. */
18796 it
->current_x
= saved_x
;
18797 it
->object
= saved_object
;
18798 it
->position
= saved_pos
;
18799 it
->what
= saved_what
;
18800 it
->face_id
= saved_face_id
;
18805 /* Value is non-zero if text starting at CHARPOS in current_buffer is
18806 trailing whitespace. */
18809 trailing_whitespace_p (ptrdiff_t charpos
)
18811 ptrdiff_t bytepos
= CHAR_TO_BYTE (charpos
);
18814 while (bytepos
< ZV_BYTE
18815 && (c
= FETCH_CHAR (bytepos
),
18816 c
== ' ' || c
== '\t'))
18819 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
18821 if (bytepos
!= PT_BYTE
)
18828 /* Highlight trailing whitespace, if any, in ROW. */
18831 highlight_trailing_whitespace (struct frame
*f
, struct glyph_row
*row
)
18833 int used
= row
->used
[TEXT_AREA
];
18837 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
18838 struct glyph
*glyph
= start
+ used
- 1;
18840 if (row
->reversed_p
)
18842 /* Right-to-left rows need to be processed in the opposite
18843 direction, so swap the edge pointers. */
18845 start
= row
->glyphs
[TEXT_AREA
] + used
- 1;
18848 /* Skip over glyphs inserted to display the cursor at the
18849 end of a line, for extending the face of the last glyph
18850 to the end of the line on terminals, and for truncation
18851 and continuation glyphs. */
18852 if (!row
->reversed_p
)
18854 while (glyph
>= start
18855 && glyph
->type
== CHAR_GLYPH
18856 && INTEGERP (glyph
->object
))
18861 while (glyph
<= start
18862 && glyph
->type
== CHAR_GLYPH
18863 && INTEGERP (glyph
->object
))
18867 /* If last glyph is a space or stretch, and it's trailing
18868 whitespace, set the face of all trailing whitespace glyphs in
18869 IT->glyph_row to `trailing-whitespace'. */
18870 if ((row
->reversed_p
? glyph
<= start
: glyph
>= start
)
18871 && BUFFERP (glyph
->object
)
18872 && (glyph
->type
== STRETCH_GLYPH
18873 || (glyph
->type
== CHAR_GLYPH
18874 && glyph
->u
.ch
== ' '))
18875 && trailing_whitespace_p (glyph
->charpos
))
18877 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
18881 if (!row
->reversed_p
)
18883 while (glyph
>= start
18884 && BUFFERP (glyph
->object
)
18885 && (glyph
->type
== STRETCH_GLYPH
18886 || (glyph
->type
== CHAR_GLYPH
18887 && glyph
->u
.ch
== ' ')))
18888 (glyph
--)->face_id
= face_id
;
18892 while (glyph
<= start
18893 && BUFFERP (glyph
->object
)
18894 && (glyph
->type
== STRETCH_GLYPH
18895 || (glyph
->type
== CHAR_GLYPH
18896 && glyph
->u
.ch
== ' ')))
18897 (glyph
++)->face_id
= face_id
;
18904 /* Value is non-zero if glyph row ROW should be
18905 used to hold the cursor. */
18908 cursor_row_p (struct glyph_row
*row
)
18912 if (PT
== CHARPOS (row
->end
.pos
)
18913 || PT
== MATRIX_ROW_END_CHARPOS (row
))
18915 /* Suppose the row ends on a string.
18916 Unless the row is continued, that means it ends on a newline
18917 in the string. If it's anything other than a display string
18918 (e.g., a before-string from an overlay), we don't want the
18919 cursor there. (This heuristic seems to give the optimal
18920 behavior for the various types of multi-line strings.)
18921 One exception: if the string has `cursor' property on one of
18922 its characters, we _do_ want the cursor there. */
18923 if (CHARPOS (row
->end
.string_pos
) >= 0)
18925 if (row
->continued_p
)
18929 /* Check for `display' property. */
18930 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
18931 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
18932 struct glyph
*glyph
;
18935 for (glyph
= end
; glyph
>= beg
; --glyph
)
18936 if (STRINGP (glyph
->object
))
18939 = Fget_char_property (make_number (PT
),
18943 && display_prop_string_p (prop
, glyph
->object
));
18944 /* If there's a `cursor' property on one of the
18945 string's characters, this row is a cursor row,
18946 even though this is not a display string. */
18949 Lisp_Object s
= glyph
->object
;
18951 for ( ; glyph
>= beg
&& EQ (glyph
->object
, s
); --glyph
)
18953 ptrdiff_t gpos
= glyph
->charpos
;
18955 if (!NILP (Fget_char_property (make_number (gpos
),
18967 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
18969 /* If the row ends in middle of a real character,
18970 and the line is continued, we want the cursor here.
18971 That's because CHARPOS (ROW->end.pos) would equal
18972 PT if PT is before the character. */
18973 if (!row
->ends_in_ellipsis_p
)
18974 result
= row
->continued_p
;
18976 /* If the row ends in an ellipsis, then
18977 CHARPOS (ROW->end.pos) will equal point after the
18978 invisible text. We want that position to be displayed
18979 after the ellipsis. */
18982 /* If the row ends at ZV, display the cursor at the end of that
18983 row instead of at the start of the row below. */
18984 else if (row
->ends_at_zv_p
)
18995 /* Push the property PROP so that it will be rendered at the current
18996 position in IT. Return 1 if PROP was successfully pushed, 0
18997 otherwise. Called from handle_line_prefix to handle the
18998 `line-prefix' and `wrap-prefix' properties. */
19001 push_prefix_prop (struct it
*it
, Lisp_Object prop
)
19003 struct text_pos pos
=
19004 STRINGP (it
->string
) ? it
->current
.string_pos
: it
->current
.pos
;
19006 eassert (it
->method
== GET_FROM_BUFFER
19007 || it
->method
== GET_FROM_DISPLAY_VECTOR
19008 || it
->method
== GET_FROM_STRING
);
19010 /* We need to save the current buffer/string position, so it will be
19011 restored by pop_it, because iterate_out_of_display_property
19012 depends on that being set correctly, but some situations leave
19013 it->position not yet set when this function is called. */
19014 push_it (it
, &pos
);
19016 if (STRINGP (prop
))
19018 if (SCHARS (prop
) == 0)
19025 it
->string_from_prefix_prop_p
= 1;
19026 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
19027 it
->current
.overlay_string_index
= -1;
19028 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
19029 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
19030 it
->method
= GET_FROM_STRING
;
19031 it
->stop_charpos
= 0;
19033 it
->base_level_stop
= 0;
19035 /* Force paragraph direction to be that of the parent
19037 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
19038 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
19040 it
->paragraph_embedding
= L2R
;
19042 /* Set up the bidi iterator for this display string. */
19045 it
->bidi_it
.string
.lstring
= it
->string
;
19046 it
->bidi_it
.string
.s
= NULL
;
19047 it
->bidi_it
.string
.schars
= it
->end_charpos
;
19048 it
->bidi_it
.string
.bufpos
= IT_CHARPOS (*it
);
19049 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
19050 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
19051 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
19054 else if (CONSP (prop
) && EQ (XCAR (prop
), Qspace
))
19056 it
->method
= GET_FROM_STRETCH
;
19059 #ifdef HAVE_WINDOW_SYSTEM
19060 else if (IMAGEP (prop
))
19062 it
->what
= IT_IMAGE
;
19063 it
->image_id
= lookup_image (it
->f
, prop
);
19064 it
->method
= GET_FROM_IMAGE
;
19066 #endif /* HAVE_WINDOW_SYSTEM */
19069 pop_it (it
); /* bogus display property, give up */
19076 /* Return the character-property PROP at the current position in IT. */
19079 get_it_property (struct it
*it
, Lisp_Object prop
)
19081 Lisp_Object position
;
19083 if (STRINGP (it
->object
))
19084 position
= make_number (IT_STRING_CHARPOS (*it
));
19085 else if (BUFFERP (it
->object
))
19086 position
= make_number (IT_CHARPOS (*it
));
19090 return Fget_char_property (position
, prop
, it
->object
);
19093 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
19096 handle_line_prefix (struct it
*it
)
19098 Lisp_Object prefix
;
19100 if (it
->continuation_lines_width
> 0)
19102 prefix
= get_it_property (it
, Qwrap_prefix
);
19104 prefix
= Vwrap_prefix
;
19108 prefix
= get_it_property (it
, Qline_prefix
);
19110 prefix
= Vline_prefix
;
19112 if (! NILP (prefix
) && push_prefix_prop (it
, prefix
))
19114 /* If the prefix is wider than the window, and we try to wrap
19115 it, it would acquire its own wrap prefix, and so on till the
19116 iterator stack overflows. So, don't wrap the prefix. */
19117 it
->line_wrap
= TRUNCATE
;
19118 it
->avoid_cursor_p
= 1;
19124 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
19125 only for R2L lines from display_line and display_string, when they
19126 decide that too many glyphs were produced by PRODUCE_GLYPHS, and
19127 the line/string needs to be continued on the next glyph row. */
19129 unproduce_glyphs (struct it
*it
, int n
)
19131 struct glyph
*glyph
, *end
;
19133 eassert (it
->glyph_row
);
19134 eassert (it
->glyph_row
->reversed_p
);
19135 eassert (it
->area
== TEXT_AREA
);
19136 eassert (n
<= it
->glyph_row
->used
[TEXT_AREA
]);
19138 if (n
> it
->glyph_row
->used
[TEXT_AREA
])
19139 n
= it
->glyph_row
->used
[TEXT_AREA
];
19140 glyph
= it
->glyph_row
->glyphs
[TEXT_AREA
] + n
;
19141 end
= it
->glyph_row
->glyphs
[TEXT_AREA
] + it
->glyph_row
->used
[TEXT_AREA
];
19142 for ( ; glyph
< end
; glyph
++)
19143 glyph
[-n
] = *glyph
;
19146 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
19147 and ROW->maxpos. */
19149 find_row_edges (struct it
*it
, struct glyph_row
*row
,
19150 ptrdiff_t min_pos
, ptrdiff_t min_bpos
,
19151 ptrdiff_t max_pos
, ptrdiff_t max_bpos
)
19153 /* FIXME: Revisit this when glyph ``spilling'' in continuation
19154 lines' rows is implemented for bidi-reordered rows. */
19156 /* ROW->minpos is the value of min_pos, the minimal buffer position
19157 we have in ROW, or ROW->start.pos if that is smaller. */
19158 if (min_pos
<= ZV
&& min_pos
< row
->start
.pos
.charpos
)
19159 SET_TEXT_POS (row
->minpos
, min_pos
, min_bpos
);
19161 /* We didn't find buffer positions smaller than ROW->start, or
19162 didn't find _any_ valid buffer positions in any of the glyphs,
19163 so we must trust the iterator's computed positions. */
19164 row
->minpos
= row
->start
.pos
;
19167 max_pos
= CHARPOS (it
->current
.pos
);
19168 max_bpos
= BYTEPOS (it
->current
.pos
);
19171 /* Here are the various use-cases for ending the row, and the
19172 corresponding values for ROW->maxpos:
19174 Line ends in a newline from buffer eol_pos + 1
19175 Line is continued from buffer max_pos + 1
19176 Line is truncated on right it->current.pos
19177 Line ends in a newline from string max_pos + 1(*)
19178 (*) + 1 only when line ends in a forward scan
19179 Line is continued from string max_pos
19180 Line is continued from display vector max_pos
19181 Line is entirely from a string min_pos == max_pos
19182 Line is entirely from a display vector min_pos == max_pos
19183 Line that ends at ZV ZV
19185 If you discover other use-cases, please add them here as
19187 if (row
->ends_at_zv_p
)
19188 row
->maxpos
= it
->current
.pos
;
19189 else if (row
->used
[TEXT_AREA
])
19191 int seen_this_string
= 0;
19192 struct glyph_row
*r1
= row
- 1;
19194 /* Did we see the same display string on the previous row? */
19195 if (STRINGP (it
->object
)
19196 /* this is not the first row */
19197 && row
> it
->w
->desired_matrix
->rows
19198 /* previous row is not the header line */
19199 && !r1
->mode_line_p
19200 /* previous row also ends in a newline from a string */
19201 && r1
->ends_in_newline_from_string_p
)
19203 struct glyph
*start
, *end
;
19205 /* Search for the last glyph of the previous row that came
19206 from buffer or string. Depending on whether the row is
19207 L2R or R2L, we need to process it front to back or the
19208 other way round. */
19209 if (!r1
->reversed_p
)
19211 start
= r1
->glyphs
[TEXT_AREA
];
19212 end
= start
+ r1
->used
[TEXT_AREA
];
19213 /* Glyphs inserted by redisplay have an integer (zero)
19214 as their object. */
19216 && INTEGERP ((end
- 1)->object
)
19217 && (end
- 1)->charpos
<= 0)
19221 if (EQ ((end
- 1)->object
, it
->object
))
19222 seen_this_string
= 1;
19225 /* If all the glyphs of the previous row were inserted
19226 by redisplay, it means the previous row was
19227 produced from a single newline, which is only
19228 possible if that newline came from the same string
19229 as the one which produced this ROW. */
19230 seen_this_string
= 1;
19234 end
= r1
->glyphs
[TEXT_AREA
] - 1;
19235 start
= end
+ r1
->used
[TEXT_AREA
];
19237 && INTEGERP ((end
+ 1)->object
)
19238 && (end
+ 1)->charpos
<= 0)
19242 if (EQ ((end
+ 1)->object
, it
->object
))
19243 seen_this_string
= 1;
19246 seen_this_string
= 1;
19249 /* Take note of each display string that covers a newline only
19250 once, the first time we see it. This is for when a display
19251 string includes more than one newline in it. */
19252 if (row
->ends_in_newline_from_string_p
&& !seen_this_string
)
19254 /* If we were scanning the buffer forward when we displayed
19255 the string, we want to account for at least one buffer
19256 position that belongs to this row (position covered by
19257 the display string), so that cursor positioning will
19258 consider this row as a candidate when point is at the end
19259 of the visual line represented by this row. This is not
19260 required when scanning back, because max_pos will already
19261 have a much larger value. */
19262 if (CHARPOS (row
->end
.pos
) > max_pos
)
19263 INC_BOTH (max_pos
, max_bpos
);
19264 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19266 else if (CHARPOS (it
->eol_pos
) > 0)
19267 SET_TEXT_POS (row
->maxpos
,
19268 CHARPOS (it
->eol_pos
) + 1, BYTEPOS (it
->eol_pos
) + 1);
19269 else if (row
->continued_p
)
19271 /* If max_pos is different from IT's current position, it
19272 means IT->method does not belong to the display element
19273 at max_pos. However, it also means that the display
19274 element at max_pos was displayed in its entirety on this
19275 line, which is equivalent to saying that the next line
19276 starts at the next buffer position. */
19277 if (IT_CHARPOS (*it
) == max_pos
&& it
->method
!= GET_FROM_BUFFER
)
19278 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19281 INC_BOTH (max_pos
, max_bpos
);
19282 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19285 else if (row
->truncated_on_right_p
)
19286 /* display_line already called reseat_at_next_visible_line_start,
19287 which puts the iterator at the beginning of the next line, in
19288 the logical order. */
19289 row
->maxpos
= it
->current
.pos
;
19290 else if (max_pos
== min_pos
&& it
->method
!= GET_FROM_BUFFER
)
19291 /* A line that is entirely from a string/image/stretch... */
19292 row
->maxpos
= row
->minpos
;
19297 row
->maxpos
= it
->current
.pos
;
19300 /* Construct the glyph row IT->glyph_row in the desired matrix of
19301 IT->w from text at the current position of IT. See dispextern.h
19302 for an overview of struct it. Value is non-zero if
19303 IT->glyph_row displays text, as opposed to a line displaying ZV
19307 display_line (struct it
*it
)
19309 struct glyph_row
*row
= it
->glyph_row
;
19310 Lisp_Object overlay_arrow_string
;
19312 void *wrap_data
= NULL
;
19313 int may_wrap
= 0, wrap_x
IF_LINT (= 0);
19314 int wrap_row_used
= -1;
19315 int wrap_row_ascent
IF_LINT (= 0), wrap_row_height
IF_LINT (= 0);
19316 int wrap_row_phys_ascent
IF_LINT (= 0), wrap_row_phys_height
IF_LINT (= 0);
19317 int wrap_row_extra_line_spacing
IF_LINT (= 0);
19318 ptrdiff_t wrap_row_min_pos
IF_LINT (= 0), wrap_row_min_bpos
IF_LINT (= 0);
19319 ptrdiff_t wrap_row_max_pos
IF_LINT (= 0), wrap_row_max_bpos
IF_LINT (= 0);
19321 ptrdiff_t min_pos
= ZV
+ 1, max_pos
= 0;
19322 ptrdiff_t min_bpos
IF_LINT (= 0), max_bpos
IF_LINT (= 0);
19324 /* We always start displaying at hpos zero even if hscrolled. */
19325 eassert (it
->hpos
== 0 && it
->current_x
== 0);
19327 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
19328 >= it
->w
->desired_matrix
->nrows
)
19330 it
->w
->nrows_scale_factor
++;
19331 fonts_changed_p
= 1;
19335 /* Is IT->w showing the region? */
19336 wset_region_showing (it
->w
, it
->region_beg_charpos
> 0 ? Qt
: Qnil
);
19338 /* Clear the result glyph row and enable it. */
19339 prepare_desired_row (row
);
19341 row
->y
= it
->current_y
;
19342 row
->start
= it
->start
;
19343 row
->continuation_lines_width
= it
->continuation_lines_width
;
19344 row
->displays_text_p
= 1;
19345 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
19346 it
->starts_in_middle_of_char_p
= 0;
19348 /* Arrange the overlays nicely for our purposes. Usually, we call
19349 display_line on only one line at a time, in which case this
19350 can't really hurt too much, or we call it on lines which appear
19351 one after another in the buffer, in which case all calls to
19352 recenter_overlay_lists but the first will be pretty cheap. */
19353 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
19355 /* Move over display elements that are not visible because we are
19356 hscrolled. This may stop at an x-position < IT->first_visible_x
19357 if the first glyph is partially visible or if we hit a line end. */
19358 if (it
->current_x
< it
->first_visible_x
)
19360 enum move_it_result move_result
;
19362 this_line_min_pos
= row
->start
.pos
;
19363 move_result
= move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
19364 MOVE_TO_POS
| MOVE_TO_X
);
19365 /* If we are under a large hscroll, move_it_in_display_line_to
19366 could hit the end of the line without reaching
19367 it->first_visible_x. Pretend that we did reach it. This is
19368 especially important on a TTY, where we will call
19369 extend_face_to_end_of_line, which needs to know how many
19370 blank glyphs to produce. */
19371 if (it
->current_x
< it
->first_visible_x
19372 && (move_result
== MOVE_NEWLINE_OR_CR
19373 || move_result
== MOVE_POS_MATCH_OR_ZV
))
19374 it
->current_x
= it
->first_visible_x
;
19376 /* Record the smallest positions seen while we moved over
19377 display elements that are not visible. This is needed by
19378 redisplay_internal for optimizing the case where the cursor
19379 stays inside the same line. The rest of this function only
19380 considers positions that are actually displayed, so
19381 RECORD_MAX_MIN_POS will not otherwise record positions that
19382 are hscrolled to the left of the left edge of the window. */
19383 min_pos
= CHARPOS (this_line_min_pos
);
19384 min_bpos
= BYTEPOS (this_line_min_pos
);
19388 /* We only do this when not calling `move_it_in_display_line_to'
19389 above, because move_it_in_display_line_to calls
19390 handle_line_prefix itself. */
19391 handle_line_prefix (it
);
19394 /* Get the initial row height. This is either the height of the
19395 text hscrolled, if there is any, or zero. */
19396 row
->ascent
= it
->max_ascent
;
19397 row
->height
= it
->max_ascent
+ it
->max_descent
;
19398 row
->phys_ascent
= it
->max_phys_ascent
;
19399 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
19400 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
19402 /* Utility macro to record max and min buffer positions seen until now. */
19403 #define RECORD_MAX_MIN_POS(IT) \
19406 int composition_p = !STRINGP ((IT)->string) \
19407 && ((IT)->what == IT_COMPOSITION); \
19408 ptrdiff_t current_pos = \
19409 composition_p ? (IT)->cmp_it.charpos \
19410 : IT_CHARPOS (*(IT)); \
19411 ptrdiff_t current_bpos = \
19412 composition_p ? CHAR_TO_BYTE (current_pos) \
19413 : IT_BYTEPOS (*(IT)); \
19414 if (current_pos < min_pos) \
19416 min_pos = current_pos; \
19417 min_bpos = current_bpos; \
19419 if (IT_CHARPOS (*it) > max_pos) \
19421 max_pos = IT_CHARPOS (*it); \
19422 max_bpos = IT_BYTEPOS (*it); \
19427 /* Loop generating characters. The loop is left with IT on the next
19428 character to display. */
19431 int n_glyphs_before
, hpos_before
, x_before
;
19433 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
19435 /* Retrieve the next thing to display. Value is zero if end of
19437 if (!get_next_display_element (it
))
19439 /* Maybe add a space at the end of this line that is used to
19440 display the cursor there under X. Set the charpos of the
19441 first glyph of blank lines not corresponding to any text
19443 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19444 row
->exact_window_width_line_p
= 1;
19445 else if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
19446 || row
->used
[TEXT_AREA
] == 0)
19448 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
19449 row
->displays_text_p
= 0;
19451 if (!NILP (BVAR (XBUFFER (it
->w
->buffer
), indicate_empty_lines
))
19452 && (!MINI_WINDOW_P (it
->w
)
19453 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
19454 row
->indicate_empty_line_p
= 1;
19457 it
->continuation_lines_width
= 0;
19458 row
->ends_at_zv_p
= 1;
19459 /* A row that displays right-to-left text must always have
19460 its last face extended all the way to the end of line,
19461 even if this row ends in ZV, because we still write to
19462 the screen left to right. We also need to extend the
19463 last face if the default face is remapped to some
19464 different face, otherwise the functions that clear
19465 portions of the screen will clear with the default face's
19466 background color. */
19467 if (row
->reversed_p
19468 || lookup_basic_face (it
->f
, DEFAULT_FACE_ID
) != DEFAULT_FACE_ID
)
19469 extend_face_to_end_of_line (it
);
19473 /* Now, get the metrics of what we want to display. This also
19474 generates glyphs in `row' (which is IT->glyph_row). */
19475 n_glyphs_before
= row
->used
[TEXT_AREA
];
19478 /* Remember the line height so far in case the next element doesn't
19479 fit on the line. */
19480 if (it
->line_wrap
!= TRUNCATE
)
19482 ascent
= it
->max_ascent
;
19483 descent
= it
->max_descent
;
19484 phys_ascent
= it
->max_phys_ascent
;
19485 phys_descent
= it
->max_phys_descent
;
19487 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
19489 if (IT_DISPLAYING_WHITESPACE (it
))
19493 SAVE_IT (wrap_it
, *it
, wrap_data
);
19495 wrap_row_used
= row
->used
[TEXT_AREA
];
19496 wrap_row_ascent
= row
->ascent
;
19497 wrap_row_height
= row
->height
;
19498 wrap_row_phys_ascent
= row
->phys_ascent
;
19499 wrap_row_phys_height
= row
->phys_height
;
19500 wrap_row_extra_line_spacing
= row
->extra_line_spacing
;
19501 wrap_row_min_pos
= min_pos
;
19502 wrap_row_min_bpos
= min_bpos
;
19503 wrap_row_max_pos
= max_pos
;
19504 wrap_row_max_bpos
= max_bpos
;
19510 PRODUCE_GLYPHS (it
);
19512 /* If this display element was in marginal areas, continue with
19514 if (it
->area
!= TEXT_AREA
)
19516 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19517 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19518 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19519 row
->phys_height
= max (row
->phys_height
,
19520 it
->max_phys_ascent
+ it
->max_phys_descent
);
19521 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19522 it
->max_extra_line_spacing
);
19523 set_iterator_to_next (it
, 1);
19527 /* Does the display element fit on the line? If we truncate
19528 lines, we should draw past the right edge of the window. If
19529 we don't truncate, we want to stop so that we can display the
19530 continuation glyph before the right margin. If lines are
19531 continued, there are two possible strategies for characters
19532 resulting in more than 1 glyph (e.g. tabs): Display as many
19533 glyphs as possible in this line and leave the rest for the
19534 continuation line, or display the whole element in the next
19535 line. Original redisplay did the former, so we do it also. */
19536 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
19537 hpos_before
= it
->hpos
;
19540 if (/* Not a newline. */
19542 /* Glyphs produced fit entirely in the line. */
19543 && it
->current_x
< it
->last_visible_x
)
19545 it
->hpos
+= nglyphs
;
19546 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19547 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19548 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19549 row
->phys_height
= max (row
->phys_height
,
19550 it
->max_phys_ascent
+ it
->max_phys_descent
);
19551 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19552 it
->max_extra_line_spacing
);
19553 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
19554 row
->x
= x
- it
->first_visible_x
;
19555 /* Record the maximum and minimum buffer positions seen so
19556 far in glyphs that will be displayed by this row. */
19558 RECORD_MAX_MIN_POS (it
);
19563 struct glyph
*glyph
;
19565 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
19567 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
19568 new_x
= x
+ glyph
->pixel_width
;
19570 if (/* Lines are continued. */
19571 it
->line_wrap
!= TRUNCATE
19572 && (/* Glyph doesn't fit on the line. */
19573 new_x
> it
->last_visible_x
19574 /* Or it fits exactly on a window system frame. */
19575 || (new_x
== it
->last_visible_x
19576 && FRAME_WINDOW_P (it
->f
)
19577 && (row
->reversed_p
19578 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19579 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
19581 /* End of a continued line. */
19584 || (new_x
== it
->last_visible_x
19585 && FRAME_WINDOW_P (it
->f
)
19586 && (row
->reversed_p
19587 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19588 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
))))
19590 /* Current glyph is the only one on the line or
19591 fits exactly on the line. We must continue
19592 the line because we can't draw the cursor
19593 after the glyph. */
19594 row
->continued_p
= 1;
19595 it
->current_x
= new_x
;
19596 it
->continuation_lines_width
+= new_x
;
19598 if (i
== nglyphs
- 1)
19600 /* If line-wrap is on, check if a previous
19601 wrap point was found. */
19602 if (wrap_row_used
> 0
19603 /* Even if there is a previous wrap
19604 point, continue the line here as
19605 usual, if (i) the previous character
19606 was a space or tab AND (ii) the
19607 current character is not. */
19609 || IT_DISPLAYING_WHITESPACE (it
)))
19612 /* Record the maximum and minimum buffer
19613 positions seen so far in glyphs that will be
19614 displayed by this row. */
19616 RECORD_MAX_MIN_POS (it
);
19617 set_iterator_to_next (it
, 1);
19618 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19620 if (!get_next_display_element (it
))
19622 row
->exact_window_width_line_p
= 1;
19623 it
->continuation_lines_width
= 0;
19624 row
->continued_p
= 0;
19625 row
->ends_at_zv_p
= 1;
19627 else if (ITERATOR_AT_END_OF_LINE_P (it
))
19629 row
->continued_p
= 0;
19630 row
->exact_window_width_line_p
= 1;
19634 else if (it
->bidi_p
)
19635 RECORD_MAX_MIN_POS (it
);
19637 else if (CHAR_GLYPH_PADDING_P (*glyph
)
19638 && !FRAME_WINDOW_P (it
->f
))
19640 /* A padding glyph that doesn't fit on this line.
19641 This means the whole character doesn't fit
19643 if (row
->reversed_p
)
19644 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
19645 - n_glyphs_before
);
19646 row
->used
[TEXT_AREA
] = n_glyphs_before
;
19648 /* Fill the rest of the row with continuation
19649 glyphs like in 20.x. */
19650 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
19651 < row
->glyphs
[1 + TEXT_AREA
])
19652 produce_special_glyphs (it
, IT_CONTINUATION
);
19654 row
->continued_p
= 1;
19655 it
->current_x
= x_before
;
19656 it
->continuation_lines_width
+= x_before
;
19658 /* Restore the height to what it was before the
19659 element not fitting on the line. */
19660 it
->max_ascent
= ascent
;
19661 it
->max_descent
= descent
;
19662 it
->max_phys_ascent
= phys_ascent
;
19663 it
->max_phys_descent
= phys_descent
;
19665 else if (wrap_row_used
> 0)
19668 if (row
->reversed_p
)
19669 unproduce_glyphs (it
,
19670 row
->used
[TEXT_AREA
] - wrap_row_used
);
19671 RESTORE_IT (it
, &wrap_it
, wrap_data
);
19672 it
->continuation_lines_width
+= wrap_x
;
19673 row
->used
[TEXT_AREA
] = wrap_row_used
;
19674 row
->ascent
= wrap_row_ascent
;
19675 row
->height
= wrap_row_height
;
19676 row
->phys_ascent
= wrap_row_phys_ascent
;
19677 row
->phys_height
= wrap_row_phys_height
;
19678 row
->extra_line_spacing
= wrap_row_extra_line_spacing
;
19679 min_pos
= wrap_row_min_pos
;
19680 min_bpos
= wrap_row_min_bpos
;
19681 max_pos
= wrap_row_max_pos
;
19682 max_bpos
= wrap_row_max_bpos
;
19683 row
->continued_p
= 1;
19684 row
->ends_at_zv_p
= 0;
19685 row
->exact_window_width_line_p
= 0;
19686 it
->continuation_lines_width
+= x
;
19688 /* Make sure that a non-default face is extended
19689 up to the right margin of the window. */
19690 extend_face_to_end_of_line (it
);
19692 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
19694 /* A TAB that extends past the right edge of the
19695 window. This produces a single glyph on
19696 window system frames. We leave the glyph in
19697 this row and let it fill the row, but don't
19698 consume the TAB. */
19699 if ((row
->reversed_p
19700 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19701 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19702 produce_special_glyphs (it
, IT_CONTINUATION
);
19703 it
->continuation_lines_width
+= it
->last_visible_x
;
19704 row
->ends_in_middle_of_char_p
= 1;
19705 row
->continued_p
= 1;
19706 glyph
->pixel_width
= it
->last_visible_x
- x
;
19707 it
->starts_in_middle_of_char_p
= 1;
19711 /* Something other than a TAB that draws past
19712 the right edge of the window. Restore
19713 positions to values before the element. */
19714 if (row
->reversed_p
)
19715 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
19716 - (n_glyphs_before
+ i
));
19717 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
19719 /* Display continuation glyphs. */
19720 it
->current_x
= x_before
;
19721 it
->continuation_lines_width
+= x
;
19722 if (!FRAME_WINDOW_P (it
->f
)
19723 || (row
->reversed_p
19724 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19725 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19726 produce_special_glyphs (it
, IT_CONTINUATION
);
19727 row
->continued_p
= 1;
19729 extend_face_to_end_of_line (it
);
19731 if (nglyphs
> 1 && i
> 0)
19733 row
->ends_in_middle_of_char_p
= 1;
19734 it
->starts_in_middle_of_char_p
= 1;
19737 /* Restore the height to what it was before the
19738 element not fitting on the line. */
19739 it
->max_ascent
= ascent
;
19740 it
->max_descent
= descent
;
19741 it
->max_phys_ascent
= phys_ascent
;
19742 it
->max_phys_descent
= phys_descent
;
19747 else if (new_x
> it
->first_visible_x
)
19749 /* Increment number of glyphs actually displayed. */
19752 /* Record the maximum and minimum buffer positions
19753 seen so far in glyphs that will be displayed by
19756 RECORD_MAX_MIN_POS (it
);
19758 if (x
< it
->first_visible_x
)
19759 /* Glyph is partially visible, i.e. row starts at
19760 negative X position. */
19761 row
->x
= x
- it
->first_visible_x
;
19765 /* Glyph is completely off the left margin of the
19766 window. This should not happen because of the
19767 move_it_in_display_line at the start of this
19768 function, unless the text display area of the
19769 window is empty. */
19770 eassert (it
->first_visible_x
<= it
->last_visible_x
);
19773 /* Even if this display element produced no glyphs at all,
19774 we want to record its position. */
19775 if (it
->bidi_p
&& nglyphs
== 0)
19776 RECORD_MAX_MIN_POS (it
);
19778 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19779 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19780 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19781 row
->phys_height
= max (row
->phys_height
,
19782 it
->max_phys_ascent
+ it
->max_phys_descent
);
19783 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19784 it
->max_extra_line_spacing
);
19786 /* End of this display line if row is continued. */
19787 if (row
->continued_p
|| row
->ends_at_zv_p
)
19792 /* Is this a line end? If yes, we're also done, after making
19793 sure that a non-default face is extended up to the right
19794 margin of the window. */
19795 if (ITERATOR_AT_END_OF_LINE_P (it
))
19797 int used_before
= row
->used
[TEXT_AREA
];
19799 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
19801 /* Add a space at the end of the line that is used to
19802 display the cursor there. */
19803 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19804 append_space_for_newline (it
, 0);
19806 /* Extend the face to the end of the line. */
19807 extend_face_to_end_of_line (it
);
19809 /* Make sure we have the position. */
19810 if (used_before
== 0)
19811 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
19813 /* Record the position of the newline, for use in
19815 it
->eol_pos
= it
->current
.pos
;
19817 /* Consume the line end. This skips over invisible lines. */
19818 set_iterator_to_next (it
, 1);
19819 it
->continuation_lines_width
= 0;
19823 /* Proceed with next display element. Note that this skips
19824 over lines invisible because of selective display. */
19825 set_iterator_to_next (it
, 1);
19827 /* If we truncate lines, we are done when the last displayed
19828 glyphs reach past the right margin of the window. */
19829 if (it
->line_wrap
== TRUNCATE
19830 && (FRAME_WINDOW_P (it
->f
) && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
19831 ? (it
->current_x
>= it
->last_visible_x
)
19832 : (it
->current_x
> it
->last_visible_x
)))
19834 /* Maybe add truncation glyphs. */
19835 if (!FRAME_WINDOW_P (it
->f
)
19836 || (row
->reversed_p
19837 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19838 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19842 if (!row
->reversed_p
)
19844 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
19845 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
19850 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
19851 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
19853 /* Remove any padding glyphs at the front of ROW, to
19854 make room for the truncation glyphs we will be
19855 adding below. The loop below always inserts at
19856 least one truncation glyph, so also remove the
19857 last glyph added to ROW. */
19858 unproduce_glyphs (it
, i
+ 1);
19859 /* Adjust i for the loop below. */
19860 i
= row
->used
[TEXT_AREA
] - (i
+ 1);
19863 it
->current_x
= x_before
;
19864 if (!FRAME_WINDOW_P (it
->f
))
19866 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
19868 row
->used
[TEXT_AREA
] = i
;
19869 produce_special_glyphs (it
, IT_TRUNCATION
);
19874 row
->used
[TEXT_AREA
] = i
;
19875 produce_special_glyphs (it
, IT_TRUNCATION
);
19878 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19880 /* Don't truncate if we can overflow newline into fringe. */
19881 if (!get_next_display_element (it
))
19883 it
->continuation_lines_width
= 0;
19884 row
->ends_at_zv_p
= 1;
19885 row
->exact_window_width_line_p
= 1;
19888 if (ITERATOR_AT_END_OF_LINE_P (it
))
19890 row
->exact_window_width_line_p
= 1;
19891 goto at_end_of_line
;
19893 it
->current_x
= x_before
;
19896 row
->truncated_on_right_p
= 1;
19897 it
->continuation_lines_width
= 0;
19898 reseat_at_next_visible_line_start (it
, 0);
19899 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
19900 it
->hpos
= hpos_before
;
19906 bidi_unshelve_cache (wrap_data
, 1);
19908 /* If line is not empty and hscrolled, maybe insert truncation glyphs
19909 at the left window margin. */
19910 if (it
->first_visible_x
19911 && IT_CHARPOS (*it
) != CHARPOS (row
->start
.pos
))
19913 if (!FRAME_WINDOW_P (it
->f
)
19914 || (row
->reversed_p
19915 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
19916 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
19917 insert_left_trunc_glyphs (it
);
19918 row
->truncated_on_left_p
= 1;
19921 /* Remember the position at which this line ends.
19923 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
19924 cannot be before the call to find_row_edges below, since that is
19925 where these positions are determined. */
19926 row
->end
= it
->current
;
19929 row
->minpos
= row
->start
.pos
;
19930 row
->maxpos
= row
->end
.pos
;
19934 /* ROW->minpos and ROW->maxpos must be the smallest and
19935 `1 + the largest' buffer positions in ROW. But if ROW was
19936 bidi-reordered, these two positions can be anywhere in the
19937 row, so we must determine them now. */
19938 find_row_edges (it
, row
, min_pos
, min_bpos
, max_pos
, max_bpos
);
19941 /* If the start of this line is the overlay arrow-position, then
19942 mark this glyph row as the one containing the overlay arrow.
19943 This is clearly a mess with variable size fonts. It would be
19944 better to let it be displayed like cursors under X. */
19945 if ((row
->displays_text_p
|| !overlay_arrow_seen
)
19946 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
19947 !NILP (overlay_arrow_string
)))
19949 /* Overlay arrow in window redisplay is a fringe bitmap. */
19950 if (STRINGP (overlay_arrow_string
))
19952 struct glyph_row
*arrow_row
19953 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
19954 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
19955 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
19956 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
19957 struct glyph
*p2
, *end
;
19959 /* Copy the arrow glyphs. */
19960 while (glyph
< arrow_end
)
19963 /* Throw away padding glyphs. */
19965 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
19966 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
19972 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
19977 eassert (INTEGERP (overlay_arrow_string
));
19978 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
19980 overlay_arrow_seen
= 1;
19983 /* Highlight trailing whitespace. */
19984 if (!NILP (Vshow_trailing_whitespace
))
19985 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
19987 /* Compute pixel dimensions of this line. */
19988 compute_line_metrics (it
);
19990 /* Implementation note: No changes in the glyphs of ROW or in their
19991 faces can be done past this point, because compute_line_metrics
19992 computes ROW's hash value and stores it within the glyph_row
19995 /* Record whether this row ends inside an ellipsis. */
19996 row
->ends_in_ellipsis_p
19997 = (it
->method
== GET_FROM_DISPLAY_VECTOR
19998 && it
->ellipsis_p
);
20000 /* Save fringe bitmaps in this row. */
20001 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
20002 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
20003 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
20004 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
20006 it
->left_user_fringe_bitmap
= 0;
20007 it
->left_user_fringe_face_id
= 0;
20008 it
->right_user_fringe_bitmap
= 0;
20009 it
->right_user_fringe_face_id
= 0;
20011 /* Maybe set the cursor. */
20012 cvpos
= it
->w
->cursor
.vpos
;
20014 /* In bidi-reordered rows, keep checking for proper cursor
20015 position even if one has been found already, because buffer
20016 positions in such rows change non-linearly with ROW->VPOS,
20017 when a line is continued. One exception: when we are at ZV,
20018 display cursor on the first suitable glyph row, since all
20019 the empty rows after that also have their position set to ZV. */
20020 /* FIXME: Revisit this when glyph ``spilling'' in continuation
20021 lines' rows is implemented for bidi-reordered rows. */
20023 && !MATRIX_ROW (it
->w
->desired_matrix
, cvpos
)->ends_at_zv_p
))
20024 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
20025 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
20026 && cursor_row_p (row
))
20027 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
20029 /* Prepare for the next line. This line starts horizontally at (X
20030 HPOS) = (0 0). Vertical positions are incremented. As a
20031 convenience for the caller, IT->glyph_row is set to the next
20033 it
->current_x
= it
->hpos
= 0;
20034 it
->current_y
+= row
->height
;
20035 SET_TEXT_POS (it
->eol_pos
, 0, 0);
20038 /* The next row should by default use the same value of the
20039 reversed_p flag as this one. set_iterator_to_next decides when
20040 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
20041 the flag accordingly. */
20042 if (it
->glyph_row
< MATRIX_BOTTOM_TEXT_ROW (it
->w
->desired_matrix
, it
->w
))
20043 it
->glyph_row
->reversed_p
= row
->reversed_p
;
20044 it
->start
= row
->end
;
20045 return row
->displays_text_p
;
20047 #undef RECORD_MAX_MIN_POS
20050 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction
,
20051 Scurrent_bidi_paragraph_direction
, 0, 1, 0,
20052 doc
: /* Return paragraph direction at point in BUFFER.
20053 Value is either `left-to-right' or `right-to-left'.
20054 If BUFFER is omitted or nil, it defaults to the current buffer.
20056 Paragraph direction determines how the text in the paragraph is displayed.
20057 In left-to-right paragraphs, text begins at the left margin of the window
20058 and the reading direction is generally left to right. In right-to-left
20059 paragraphs, text begins at the right margin and is read from right to left.
20061 See also `bidi-paragraph-direction'. */)
20062 (Lisp_Object buffer
)
20064 struct buffer
*buf
= current_buffer
;
20065 struct buffer
*old
= buf
;
20067 if (! NILP (buffer
))
20069 CHECK_BUFFER (buffer
);
20070 buf
= XBUFFER (buffer
);
20073 if (NILP (BVAR (buf
, bidi_display_reordering
))
20074 || NILP (BVAR (buf
, enable_multibyte_characters
))
20075 /* When we are loading loadup.el, the character property tables
20076 needed for bidi iteration are not yet available. */
20077 || !NILP (Vpurify_flag
))
20078 return Qleft_to_right
;
20079 else if (!NILP (BVAR (buf
, bidi_paragraph_direction
)))
20080 return BVAR (buf
, bidi_paragraph_direction
);
20083 /* Determine the direction from buffer text. We could try to
20084 use current_matrix if it is up to date, but this seems fast
20085 enough as it is. */
20086 struct bidi_it itb
;
20087 ptrdiff_t pos
= BUF_PT (buf
);
20088 ptrdiff_t bytepos
= BUF_PT_BYTE (buf
);
20090 void *itb_data
= bidi_shelve_cache ();
20092 set_buffer_temp (buf
);
20093 /* bidi_paragraph_init finds the base direction of the paragraph
20094 by searching forward from paragraph start. We need the base
20095 direction of the current or _previous_ paragraph, so we need
20096 to make sure we are within that paragraph. To that end, find
20097 the previous non-empty line. */
20098 if (pos
>= ZV
&& pos
> BEGV
)
20101 bytepos
= CHAR_TO_BYTE (pos
);
20103 if (fast_looking_at (build_string ("[\f\t ]*\n"),
20104 pos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) > 0)
20106 while ((c
= FETCH_BYTE (bytepos
)) == '\n'
20107 || c
== ' ' || c
== '\t' || c
== '\f')
20109 if (bytepos
<= BEGV_BYTE
)
20114 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos
)))
20117 bidi_init_it (pos
, bytepos
, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb
);
20118 itb
.paragraph_dir
= NEUTRAL_DIR
;
20119 itb
.string
.s
= NULL
;
20120 itb
.string
.lstring
= Qnil
;
20121 itb
.string
.bufpos
= 0;
20122 itb
.string
.unibyte
= 0;
20123 bidi_paragraph_init (NEUTRAL_DIR
, &itb
, 1);
20124 bidi_unshelve_cache (itb_data
, 0);
20125 set_buffer_temp (old
);
20126 switch (itb
.paragraph_dir
)
20129 return Qleft_to_right
;
20132 return Qright_to_left
;
20142 /***********************************************************************
20144 ***********************************************************************/
20146 /* Redisplay the menu bar in the frame for window W.
20148 The menu bar of X frames that don't have X toolkit support is
20149 displayed in a special window W->frame->menu_bar_window.
20151 The menu bar of terminal frames is treated specially as far as
20152 glyph matrices are concerned. Menu bar lines are not part of
20153 windows, so the update is done directly on the frame matrix rows
20154 for the menu bar. */
20157 display_menu_bar (struct window
*w
)
20159 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
20164 /* Don't do all this for graphical frames. */
20166 if (FRAME_W32_P (f
))
20169 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
20175 if (FRAME_NS_P (f
))
20177 #endif /* HAVE_NS */
20179 #ifdef USE_X_TOOLKIT
20180 eassert (!FRAME_WINDOW_P (f
));
20181 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
20182 it
.first_visible_x
= 0;
20183 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
20184 #else /* not USE_X_TOOLKIT */
20185 if (FRAME_WINDOW_P (f
))
20187 /* Menu bar lines are displayed in the desired matrix of the
20188 dummy window menu_bar_window. */
20189 struct window
*menu_w
;
20190 eassert (WINDOWP (f
->menu_bar_window
));
20191 menu_w
= XWINDOW (f
->menu_bar_window
);
20192 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
20194 it
.first_visible_x
= 0;
20195 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
20199 /* This is a TTY frame, i.e. character hpos/vpos are used as
20201 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
20203 it
.first_visible_x
= 0;
20204 it
.last_visible_x
= FRAME_COLS (f
);
20206 #endif /* not USE_X_TOOLKIT */
20208 /* FIXME: This should be controlled by a user option. See the
20209 comments in redisplay_tool_bar and display_mode_line about
20211 it
.paragraph_embedding
= L2R
;
20213 /* Clear all rows of the menu bar. */
20214 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
20216 struct glyph_row
*row
= it
.glyph_row
+ i
;
20217 clear_glyph_row (row
);
20218 row
->enabled_p
= 1;
20219 row
->full_width_p
= 1;
20222 /* Display all items of the menu bar. */
20223 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
20224 for (i
= 0; i
< ASIZE (items
); i
+= 4)
20226 Lisp_Object string
;
20228 /* Stop at nil string. */
20229 string
= AREF (items
, i
+ 1);
20233 /* Remember where item was displayed. */
20234 ASET (items
, i
+ 3, make_number (it
.hpos
));
20236 /* Display the item, pad with one space. */
20237 if (it
.current_x
< it
.last_visible_x
)
20238 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
20239 SCHARS (string
) + 1, 0, 0, -1);
20242 /* Fill out the line with spaces. */
20243 if (it
.current_x
< it
.last_visible_x
)
20244 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
20246 /* Compute the total height of the lines. */
20247 compute_line_metrics (&it
);
20252 /***********************************************************************
20254 ***********************************************************************/
20256 /* Redisplay mode lines in the window tree whose root is WINDOW. If
20257 FORCE is non-zero, redisplay mode lines unconditionally.
20258 Otherwise, redisplay only mode lines that are garbaged. Value is
20259 the number of windows whose mode lines were redisplayed. */
20262 redisplay_mode_lines (Lisp_Object window
, int force
)
20266 while (!NILP (window
))
20268 struct window
*w
= XWINDOW (window
);
20270 if (WINDOWP (w
->hchild
))
20271 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
20272 else if (WINDOWP (w
->vchild
))
20273 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
20275 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
20276 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
20278 struct text_pos lpoint
;
20279 struct buffer
*old
= current_buffer
;
20281 /* Set the window's buffer for the mode line display. */
20282 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
20283 set_buffer_internal_1 (XBUFFER (w
->buffer
));
20285 /* Point refers normally to the selected window. For any
20286 other window, set up appropriate value. */
20287 if (!EQ (window
, selected_window
))
20289 struct text_pos pt
;
20291 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
20292 if (CHARPOS (pt
) < BEGV
)
20293 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
20294 else if (CHARPOS (pt
) > (ZV
- 1))
20295 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
20297 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
20300 /* Display mode lines. */
20301 clear_glyph_matrix (w
->desired_matrix
);
20302 if (display_mode_lines (w
))
20305 w
->must_be_updated_p
= 1;
20308 /* Restore old settings. */
20309 set_buffer_internal_1 (old
);
20310 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
20320 /* Display the mode and/or header line of window W. Value is the
20321 sum number of mode lines and header lines displayed. */
20324 display_mode_lines (struct window
*w
)
20326 Lisp_Object old_selected_window
, old_selected_frame
;
20329 old_selected_frame
= selected_frame
;
20330 selected_frame
= w
->frame
;
20331 old_selected_window
= selected_window
;
20332 XSETWINDOW (selected_window
, w
);
20334 /* These will be set while the mode line specs are processed. */
20335 line_number_displayed
= 0;
20336 wset_column_number_displayed (w
, Qnil
);
20338 if (WINDOW_WANTS_MODELINE_P (w
))
20340 struct window
*sel_w
= XWINDOW (old_selected_window
);
20342 /* Select mode line face based on the real selected window. */
20343 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
20344 BVAR (current_buffer
, mode_line_format
));
20348 if (WINDOW_WANTS_HEADER_LINE_P (w
))
20350 display_mode_line (w
, HEADER_LINE_FACE_ID
,
20351 BVAR (current_buffer
, header_line_format
));
20355 selected_frame
= old_selected_frame
;
20356 selected_window
= old_selected_window
;
20361 /* Display mode or header line of window W. FACE_ID specifies which
20362 line to display; it is either MODE_LINE_FACE_ID or
20363 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
20364 display. Value is the pixel height of the mode/header line
20368 display_mode_line (struct window
*w
, enum face_id face_id
, Lisp_Object format
)
20372 ptrdiff_t count
= SPECPDL_INDEX ();
20374 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
20375 /* Don't extend on a previously drawn mode-line.
20376 This may happen if called from pos_visible_p. */
20377 it
.glyph_row
->enabled_p
= 0;
20378 prepare_desired_row (it
.glyph_row
);
20380 it
.glyph_row
->mode_line_p
= 1;
20382 /* FIXME: This should be controlled by a user option. But
20383 supporting such an option is not trivial, since the mode line is
20384 made up of many separate strings. */
20385 it
.paragraph_embedding
= L2R
;
20387 record_unwind_protect (unwind_format_mode_line
,
20388 format_mode_line_unwind_data (NULL
, NULL
, Qnil
, 0));
20390 mode_line_target
= MODE_LINE_DISPLAY
;
20392 /* Temporarily make frame's keyboard the current kboard so that
20393 kboard-local variables in the mode_line_format will get the right
20395 push_kboard (FRAME_KBOARD (it
.f
));
20396 record_unwind_save_match_data ();
20397 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
20400 unbind_to (count
, Qnil
);
20402 /* Fill up with spaces. */
20403 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
20405 compute_line_metrics (&it
);
20406 it
.glyph_row
->full_width_p
= 1;
20407 it
.glyph_row
->continued_p
= 0;
20408 it
.glyph_row
->truncated_on_left_p
= 0;
20409 it
.glyph_row
->truncated_on_right_p
= 0;
20411 /* Make a 3D mode-line have a shadow at its right end. */
20412 face
= FACE_FROM_ID (it
.f
, face_id
);
20413 extend_face_to_end_of_line (&it
);
20414 if (face
->box
!= FACE_NO_BOX
)
20416 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
20417 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
20418 last
->right_box_line_p
= 1;
20421 return it
.glyph_row
->height
;
20424 /* Move element ELT in LIST to the front of LIST.
20425 Return the updated list. */
20428 move_elt_to_front (Lisp_Object elt
, Lisp_Object list
)
20430 register Lisp_Object tail
, prev
;
20431 register Lisp_Object tem
;
20435 while (CONSP (tail
))
20441 /* Splice out the link TAIL. */
20443 list
= XCDR (tail
);
20445 Fsetcdr (prev
, XCDR (tail
));
20447 /* Now make it the first. */
20448 Fsetcdr (tail
, list
);
20453 tail
= XCDR (tail
);
20457 /* Not found--return unchanged LIST. */
20461 /* Contribute ELT to the mode line for window IT->w. How it
20462 translates into text depends on its data type.
20464 IT describes the display environment in which we display, as usual.
20466 DEPTH is the depth in recursion. It is used to prevent
20467 infinite recursion here.
20469 FIELD_WIDTH is the number of characters the display of ELT should
20470 occupy in the mode line, and PRECISION is the maximum number of
20471 characters to display from ELT's representation. See
20472 display_string for details.
20474 Returns the hpos of the end of the text generated by ELT.
20476 PROPS is a property list to add to any string we encounter.
20478 If RISKY is nonzero, remove (disregard) any properties in any string
20479 we encounter, and ignore :eval and :propertize.
20481 The global variable `mode_line_target' determines whether the
20482 output is passed to `store_mode_line_noprop',
20483 `store_mode_line_string', or `display_string'. */
20486 display_mode_element (struct it
*it
, int depth
, int field_width
, int precision
,
20487 Lisp_Object elt
, Lisp_Object props
, int risky
)
20489 int n
= 0, field
, prec
;
20494 elt
= build_string ("*too-deep*");
20498 switch (XTYPE (elt
))
20502 /* A string: output it and check for %-constructs within it. */
20504 ptrdiff_t offset
= 0;
20506 if (SCHARS (elt
) > 0
20507 && (!NILP (props
) || risky
))
20509 Lisp_Object oprops
, aelt
;
20510 oprops
= Ftext_properties_at (make_number (0), elt
);
20512 /* If the starting string's properties are not what
20513 we want, translate the string. Also, if the string
20514 is risky, do that anyway. */
20516 if (NILP (Fequal (props
, oprops
)) || risky
)
20518 /* If the starting string has properties,
20519 merge the specified ones onto the existing ones. */
20520 if (! NILP (oprops
) && !risky
)
20524 oprops
= Fcopy_sequence (oprops
);
20526 while (CONSP (tem
))
20528 oprops
= Fplist_put (oprops
, XCAR (tem
),
20529 XCAR (XCDR (tem
)));
20530 tem
= XCDR (XCDR (tem
));
20535 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
20536 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
20538 /* AELT is what we want. Move it to the front
20539 without consing. */
20541 mode_line_proptrans_alist
20542 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
20548 /* If AELT has the wrong props, it is useless.
20549 so get rid of it. */
20551 mode_line_proptrans_alist
20552 = Fdelq (aelt
, mode_line_proptrans_alist
);
20554 elt
= Fcopy_sequence (elt
);
20555 Fset_text_properties (make_number (0), Flength (elt
),
20557 /* Add this item to mode_line_proptrans_alist. */
20558 mode_line_proptrans_alist
20559 = Fcons (Fcons (elt
, props
),
20560 mode_line_proptrans_alist
);
20561 /* Truncate mode_line_proptrans_alist
20562 to at most 50 elements. */
20563 tem
= Fnthcdr (make_number (50),
20564 mode_line_proptrans_alist
);
20566 XSETCDR (tem
, Qnil
);
20575 prec
= precision
- n
;
20576 switch (mode_line_target
)
20578 case MODE_LINE_NOPROP
:
20579 case MODE_LINE_TITLE
:
20580 n
+= store_mode_line_noprop (SSDATA (elt
), -1, prec
);
20582 case MODE_LINE_STRING
:
20583 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
20585 case MODE_LINE_DISPLAY
:
20586 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
20587 0, prec
, 0, STRING_MULTIBYTE (elt
));
20594 /* Handle the non-literal case. */
20596 while ((precision
<= 0 || n
< precision
)
20597 && SREF (elt
, offset
) != 0
20598 && (mode_line_target
!= MODE_LINE_DISPLAY
20599 || it
->current_x
< it
->last_visible_x
))
20601 ptrdiff_t last_offset
= offset
;
20603 /* Advance to end of string or next format specifier. */
20604 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
20607 if (offset
- 1 != last_offset
)
20609 ptrdiff_t nchars
, nbytes
;
20611 /* Output to end of string or up to '%'. Field width
20612 is length of string. Don't output more than
20613 PRECISION allows us. */
20616 prec
= c_string_width (SDATA (elt
) + last_offset
,
20617 offset
- last_offset
, precision
- n
,
20620 switch (mode_line_target
)
20622 case MODE_LINE_NOPROP
:
20623 case MODE_LINE_TITLE
:
20624 n
+= store_mode_line_noprop (SSDATA (elt
) + last_offset
, 0, prec
);
20626 case MODE_LINE_STRING
:
20628 ptrdiff_t bytepos
= last_offset
;
20629 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
20630 ptrdiff_t endpos
= (precision
<= 0
20631 ? string_byte_to_char (elt
, offset
)
20632 : charpos
+ nchars
);
20634 n
+= store_mode_line_string (NULL
,
20635 Fsubstring (elt
, make_number (charpos
),
20636 make_number (endpos
)),
20640 case MODE_LINE_DISPLAY
:
20642 ptrdiff_t bytepos
= last_offset
;
20643 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
20645 if (precision
<= 0)
20646 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
20647 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
20649 STRING_MULTIBYTE (elt
));
20654 else /* c == '%' */
20656 ptrdiff_t percent_position
= offset
;
20658 /* Get the specified minimum width. Zero means
20661 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
20662 field
= field
* 10 + c
- '0';
20664 /* Don't pad beyond the total padding allowed. */
20665 if (field_width
- n
> 0 && field
> field_width
- n
)
20666 field
= field_width
- n
;
20668 /* Note that either PRECISION <= 0 or N < PRECISION. */
20669 prec
= precision
- n
;
20672 n
+= display_mode_element (it
, depth
, field
, prec
,
20673 Vglobal_mode_string
, props
,
20678 ptrdiff_t bytepos
, charpos
;
20680 Lisp_Object string
;
20682 bytepos
= percent_position
;
20683 charpos
= (STRING_MULTIBYTE (elt
)
20684 ? string_byte_to_char (elt
, bytepos
)
20686 spec
= decode_mode_spec (it
->w
, c
, field
, &string
);
20687 multibyte
= STRINGP (string
) && STRING_MULTIBYTE (string
);
20689 switch (mode_line_target
)
20691 case MODE_LINE_NOPROP
:
20692 case MODE_LINE_TITLE
:
20693 n
+= store_mode_line_noprop (spec
, field
, prec
);
20695 case MODE_LINE_STRING
:
20697 Lisp_Object tem
= build_string (spec
);
20698 props
= Ftext_properties_at (make_number (charpos
), elt
);
20699 /* Should only keep face property in props */
20700 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
20703 case MODE_LINE_DISPLAY
:
20705 int nglyphs_before
, nwritten
;
20707 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
20708 nwritten
= display_string (spec
, string
, elt
,
20713 /* Assign to the glyphs written above the
20714 string where the `%x' came from, position
20718 struct glyph
*glyph
20719 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
20723 for (i
= 0; i
< nwritten
; ++i
)
20725 glyph
[i
].object
= elt
;
20726 glyph
[i
].charpos
= charpos
;
20743 /* A symbol: process the value of the symbol recursively
20744 as if it appeared here directly. Avoid error if symbol void.
20745 Special case: if value of symbol is a string, output the string
20748 register Lisp_Object tem
;
20750 /* If the variable is not marked as risky to set
20751 then its contents are risky to use. */
20752 if (NILP (Fget (elt
, Qrisky_local_variable
)))
20755 tem
= Fboundp (elt
);
20758 tem
= Fsymbol_value (elt
);
20759 /* If value is a string, output that string literally:
20760 don't check for % within it. */
20764 if (!EQ (tem
, elt
))
20766 /* Give up right away for nil or t. */
20776 register Lisp_Object car
, tem
;
20778 /* A cons cell: five distinct cases.
20779 If first element is :eval or :propertize, do something special.
20780 If first element is a string or a cons, process all the elements
20781 and effectively concatenate them.
20782 If first element is a negative number, truncate displaying cdr to
20783 at most that many characters. If positive, pad (with spaces)
20784 to at least that many characters.
20785 If first element is a symbol, process the cadr or caddr recursively
20786 according to whether the symbol's value is non-nil or nil. */
20788 if (EQ (car
, QCeval
))
20790 /* An element of the form (:eval FORM) means evaluate FORM
20791 and use the result as mode line elements. */
20796 if (CONSP (XCDR (elt
)))
20799 spec
= safe_eval (XCAR (XCDR (elt
)));
20800 n
+= display_mode_element (it
, depth
, field_width
- n
,
20801 precision
- n
, spec
, props
,
20805 else if (EQ (car
, QCpropertize
))
20807 /* An element of the form (:propertize ELT PROPS...)
20808 means display ELT but applying properties PROPS. */
20813 if (CONSP (XCDR (elt
)))
20814 n
+= display_mode_element (it
, depth
, field_width
- n
,
20815 precision
- n
, XCAR (XCDR (elt
)),
20816 XCDR (XCDR (elt
)), risky
);
20818 else if (SYMBOLP (car
))
20820 tem
= Fboundp (car
);
20824 /* elt is now the cdr, and we know it is a cons cell.
20825 Use its car if CAR has a non-nil value. */
20828 tem
= Fsymbol_value (car
);
20835 /* Symbol's value is nil (or symbol is unbound)
20836 Get the cddr of the original list
20837 and if possible find the caddr and use that. */
20841 else if (!CONSP (elt
))
20846 else if (INTEGERP (car
))
20848 register int lim
= XINT (car
);
20852 /* Negative int means reduce maximum width. */
20853 if (precision
<= 0)
20856 precision
= min (precision
, -lim
);
20860 /* Padding specified. Don't let it be more than
20861 current maximum. */
20863 lim
= min (precision
, lim
);
20865 /* If that's more padding than already wanted, queue it.
20866 But don't reduce padding already specified even if
20867 that is beyond the current truncation point. */
20868 field_width
= max (lim
, field_width
);
20872 else if (STRINGP (car
) || CONSP (car
))
20874 Lisp_Object halftail
= elt
;
20878 && (precision
<= 0 || n
< precision
))
20880 n
+= display_mode_element (it
, depth
,
20881 /* Do padding only after the last
20882 element in the list. */
20883 (! CONSP (XCDR (elt
))
20886 precision
- n
, XCAR (elt
),
20890 if ((len
& 1) == 0)
20891 halftail
= XCDR (halftail
);
20892 /* Check for cycle. */
20893 if (EQ (halftail
, elt
))
20902 elt
= build_string ("*invalid*");
20906 /* Pad to FIELD_WIDTH. */
20907 if (field_width
> 0 && n
< field_width
)
20909 switch (mode_line_target
)
20911 case MODE_LINE_NOPROP
:
20912 case MODE_LINE_TITLE
:
20913 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
20915 case MODE_LINE_STRING
:
20916 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
20918 case MODE_LINE_DISPLAY
:
20919 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
20928 /* Store a mode-line string element in mode_line_string_list.
20930 If STRING is non-null, display that C string. Otherwise, the Lisp
20931 string LISP_STRING is displayed.
20933 FIELD_WIDTH is the minimum number of output glyphs to produce.
20934 If STRING has fewer characters than FIELD_WIDTH, pad to the right
20935 with spaces. FIELD_WIDTH <= 0 means don't pad.
20937 PRECISION is the maximum number of characters to output from
20938 STRING. PRECISION <= 0 means don't truncate the string.
20940 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
20941 properties to the string.
20943 PROPS are the properties to add to the string.
20944 The mode_line_string_face face property is always added to the string.
20948 store_mode_line_string (const char *string
, Lisp_Object lisp_string
, int copy_string
,
20949 int field_width
, int precision
, Lisp_Object props
)
20954 if (string
!= NULL
)
20956 len
= strlen (string
);
20957 if (precision
> 0 && len
> precision
)
20959 lisp_string
= make_string (string
, len
);
20961 props
= mode_line_string_face_prop
;
20962 else if (!NILP (mode_line_string_face
))
20964 Lisp_Object face
= Fplist_get (props
, Qface
);
20965 props
= Fcopy_sequence (props
);
20967 face
= mode_line_string_face
;
20969 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
20970 props
= Fplist_put (props
, Qface
, face
);
20972 Fadd_text_properties (make_number (0), make_number (len
),
20973 props
, lisp_string
);
20977 len
= XFASTINT (Flength (lisp_string
));
20978 if (precision
> 0 && len
> precision
)
20981 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
20984 if (!NILP (mode_line_string_face
))
20988 props
= Ftext_properties_at (make_number (0), lisp_string
);
20989 face
= Fplist_get (props
, Qface
);
20991 face
= mode_line_string_face
;
20993 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
20994 props
= Fcons (Qface
, Fcons (face
, Qnil
));
20996 lisp_string
= Fcopy_sequence (lisp_string
);
20999 Fadd_text_properties (make_number (0), make_number (len
),
21000 props
, lisp_string
);
21005 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
21009 if (field_width
> len
)
21011 field_width
-= len
;
21012 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
21014 Fadd_text_properties (make_number (0), make_number (field_width
),
21015 props
, lisp_string
);
21016 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
21024 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
21026 doc
: /* Format a string out of a mode line format specification.
21027 First arg FORMAT specifies the mode line format (see `mode-line-format'
21028 for details) to use.
21030 By default, the format is evaluated for the currently selected window.
21032 Optional second arg FACE specifies the face property to put on all
21033 characters for which no face is specified. The value nil means the
21034 default face. The value t means whatever face the window's mode line
21035 currently uses (either `mode-line' or `mode-line-inactive',
21036 depending on whether the window is the selected window or not).
21037 An integer value means the value string has no text
21040 Optional third and fourth args WINDOW and BUFFER specify the window
21041 and buffer to use as the context for the formatting (defaults
21042 are the selected window and the WINDOW's buffer). */)
21043 (Lisp_Object format
, Lisp_Object face
,
21044 Lisp_Object window
, Lisp_Object buffer
)
21049 struct buffer
*old_buffer
= NULL
;
21051 int no_props
= INTEGERP (face
);
21052 ptrdiff_t count
= SPECPDL_INDEX ();
21054 int string_start
= 0;
21056 w
= decode_any_window (window
);
21057 XSETWINDOW (window
, w
);
21060 buffer
= w
->buffer
;
21061 CHECK_BUFFER (buffer
);
21063 /* Make formatting the modeline a non-op when noninteractive, otherwise
21064 there will be problems later caused by a partially initialized frame. */
21065 if (NILP (format
) || noninteractive
)
21066 return empty_unibyte_string
;
21071 face_id
= (NILP (face
) || EQ (face
, Qdefault
)) ? DEFAULT_FACE_ID
21072 : EQ (face
, Qt
) ? (EQ (window
, selected_window
)
21073 ? MODE_LINE_FACE_ID
: MODE_LINE_INACTIVE_FACE_ID
)
21074 : EQ (face
, Qmode_line
) ? MODE_LINE_FACE_ID
21075 : EQ (face
, Qmode_line_inactive
) ? MODE_LINE_INACTIVE_FACE_ID
21076 : EQ (face
, Qheader_line
) ? HEADER_LINE_FACE_ID
21077 : EQ (face
, Qtool_bar
) ? TOOL_BAR_FACE_ID
21080 old_buffer
= current_buffer
;
21082 /* Save things including mode_line_proptrans_alist,
21083 and set that to nil so that we don't alter the outer value. */
21084 record_unwind_protect (unwind_format_mode_line
,
21085 format_mode_line_unwind_data
21086 (XFRAME (WINDOW_FRAME (w
)),
21087 old_buffer
, selected_window
, 1));
21088 mode_line_proptrans_alist
= Qnil
;
21090 Fselect_window (window
, Qt
);
21091 set_buffer_internal_1 (XBUFFER (buffer
));
21093 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
21097 mode_line_target
= MODE_LINE_NOPROP
;
21098 mode_line_string_face_prop
= Qnil
;
21099 mode_line_string_list
= Qnil
;
21100 string_start
= MODE_LINE_NOPROP_LEN (0);
21104 mode_line_target
= MODE_LINE_STRING
;
21105 mode_line_string_list
= Qnil
;
21106 mode_line_string_face
= face
;
21107 mode_line_string_face_prop
21108 = (NILP (face
) ? Qnil
: Fcons (Qface
, Fcons (face
, Qnil
)));
21111 push_kboard (FRAME_KBOARD (it
.f
));
21112 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
21117 len
= MODE_LINE_NOPROP_LEN (string_start
);
21118 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
21122 mode_line_string_list
= Fnreverse (mode_line_string_list
);
21123 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
21124 empty_unibyte_string
);
21127 unbind_to (count
, Qnil
);
21131 /* Write a null-terminated, right justified decimal representation of
21132 the positive integer D to BUF using a minimal field width WIDTH. */
21135 pint2str (register char *buf
, register int width
, register ptrdiff_t d
)
21137 register char *p
= buf
;
21145 *p
++ = d
% 10 + '0';
21150 for (width
-= (int) (p
- buf
); width
> 0; --width
)
21161 /* Write a null-terminated, right justified decimal and "human
21162 readable" representation of the nonnegative integer D to BUF using
21163 a minimal field width WIDTH. D should be smaller than 999.5e24. */
21165 static const char power_letter
[] =
21179 pint2hrstr (char *buf
, int width
, ptrdiff_t d
)
21181 /* We aim to represent the nonnegative integer D as
21182 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
21183 ptrdiff_t quotient
= d
;
21185 /* -1 means: do not use TENTHS. */
21189 /* Length of QUOTIENT.TENTHS as a string. */
21195 if (1000 <= quotient
)
21197 /* Scale to the appropriate EXPONENT. */
21200 remainder
= quotient
% 1000;
21204 while (1000 <= quotient
);
21206 /* Round to nearest and decide whether to use TENTHS or not. */
21209 tenths
= remainder
/ 100;
21210 if (50 <= remainder
% 100)
21217 if (quotient
== 10)
21225 if (500 <= remainder
)
21227 if (quotient
< 999)
21238 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
21239 if (tenths
== -1 && quotient
<= 99)
21246 p
= psuffix
= buf
+ max (width
, length
);
21248 /* Print EXPONENT. */
21249 *psuffix
++ = power_letter
[exponent
];
21252 /* Print TENTHS. */
21255 *--p
= '0' + tenths
;
21259 /* Print QUOTIENT. */
21262 int digit
= quotient
% 10;
21263 *--p
= '0' + digit
;
21265 while ((quotient
/= 10) != 0);
21267 /* Print leading spaces. */
21272 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
21273 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
21274 type of CODING_SYSTEM. Return updated pointer into BUF. */
21276 static unsigned char invalid_eol_type
[] = "(*invalid*)";
21279 decode_mode_spec_coding (Lisp_Object coding_system
, register char *buf
, int eol_flag
)
21282 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
21283 const unsigned char *eol_str
;
21285 /* The EOL conversion we are using. */
21286 Lisp_Object eoltype
;
21288 val
= CODING_SYSTEM_SPEC (coding_system
);
21291 if (!VECTORP (val
)) /* Not yet decided. */
21293 *buf
++ = multibyte
? '-' : ' ';
21295 eoltype
= eol_mnemonic_undecided
;
21296 /* Don't mention EOL conversion if it isn't decided. */
21301 Lisp_Object eolvalue
;
21303 attrs
= AREF (val
, 0);
21304 eolvalue
= AREF (val
, 2);
21307 ? XFASTINT (CODING_ATTR_MNEMONIC (attrs
))
21312 /* The EOL conversion that is normal on this system. */
21314 if (NILP (eolvalue
)) /* Not yet decided. */
21315 eoltype
= eol_mnemonic_undecided
;
21316 else if (VECTORP (eolvalue
)) /* Not yet decided. */
21317 eoltype
= eol_mnemonic_undecided
;
21318 else /* eolvalue is Qunix, Qdos, or Qmac. */
21319 eoltype
= (EQ (eolvalue
, Qunix
)
21320 ? eol_mnemonic_unix
21321 : (EQ (eolvalue
, Qdos
) == 1
21322 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
21328 /* Mention the EOL conversion if it is not the usual one. */
21329 if (STRINGP (eoltype
))
21331 eol_str
= SDATA (eoltype
);
21332 eol_str_len
= SBYTES (eoltype
);
21334 else if (CHARACTERP (eoltype
))
21336 unsigned char *tmp
= alloca (MAX_MULTIBYTE_LENGTH
);
21337 int c
= XFASTINT (eoltype
);
21338 eol_str_len
= CHAR_STRING (c
, tmp
);
21343 eol_str
= invalid_eol_type
;
21344 eol_str_len
= sizeof (invalid_eol_type
) - 1;
21346 memcpy (buf
, eol_str
, eol_str_len
);
21347 buf
+= eol_str_len
;
21353 /* Return a string for the output of a mode line %-spec for window W,
21354 generated by character C. FIELD_WIDTH > 0 means pad the string
21355 returned with spaces to that value. Return a Lisp string in
21356 *STRING if the resulting string is taken from that Lisp string.
21358 Note we operate on the current buffer for most purposes,
21359 the exception being w->base_line_pos. */
21361 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
21363 static const char *
21364 decode_mode_spec (struct window
*w
, register int c
, int field_width
,
21365 Lisp_Object
*string
)
21368 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
21369 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
21370 /* We are going to use f->decode_mode_spec_buffer as the buffer to
21371 produce strings from numerical values, so limit preposterously
21372 large values of FIELD_WIDTH to avoid overrunning the buffer's
21373 end. The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
21374 bytes plus the terminating null. */
21375 int width
= min (field_width
, FRAME_MESSAGE_BUF_SIZE (f
));
21376 struct buffer
*b
= current_buffer
;
21384 if (!NILP (BVAR (b
, read_only
)))
21386 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21391 /* This differs from %* only for a modified read-only buffer. */
21392 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21394 if (!NILP (BVAR (b
, read_only
)))
21399 /* This differs from %* in ignoring read-only-ness. */
21400 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21412 if (command_loop_level
> 5)
21414 p
= decode_mode_spec_buf
;
21415 for (i
= 0; i
< command_loop_level
; i
++)
21418 return decode_mode_spec_buf
;
21426 if (command_loop_level
> 5)
21428 p
= decode_mode_spec_buf
;
21429 for (i
= 0; i
< command_loop_level
; i
++)
21432 return decode_mode_spec_buf
;
21439 /* Let lots_of_dashes be a string of infinite length. */
21440 if (mode_line_target
== MODE_LINE_NOPROP
||
21441 mode_line_target
== MODE_LINE_STRING
)
21443 if (field_width
<= 0
21444 || field_width
> sizeof (lots_of_dashes
))
21446 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
21447 decode_mode_spec_buf
[i
] = '-';
21448 decode_mode_spec_buf
[i
] = '\0';
21449 return decode_mode_spec_buf
;
21452 return lots_of_dashes
;
21456 obj
= BVAR (b
, name
);
21460 /* %c and %l are ignored in `frame-title-format'.
21461 (In redisplay_internal, the frame title is drawn _before_ the
21462 windows are updated, so the stuff which depends on actual
21463 window contents (such as %l) may fail to render properly, or
21464 even crash emacs.) */
21465 if (mode_line_target
== MODE_LINE_TITLE
)
21469 ptrdiff_t col
= current_column ();
21470 wset_column_number_displayed (w
, make_number (col
));
21471 pint2str (decode_mode_spec_buf
, width
, col
);
21472 return decode_mode_spec_buf
;
21476 #ifndef SYSTEM_MALLOC
21478 if (NILP (Vmemory_full
))
21481 return "!MEM FULL! ";
21488 /* %F displays the frame name. */
21489 if (!NILP (f
->title
))
21490 return SSDATA (f
->title
);
21491 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
21492 return SSDATA (f
->name
);
21496 obj
= BVAR (b
, filename
);
21501 ptrdiff_t size
= ZV
- BEGV
;
21502 pint2str (decode_mode_spec_buf
, width
, size
);
21503 return decode_mode_spec_buf
;
21508 ptrdiff_t size
= ZV
- BEGV
;
21509 pint2hrstr (decode_mode_spec_buf
, width
, size
);
21510 return decode_mode_spec_buf
;
21515 ptrdiff_t startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
21516 ptrdiff_t topline
, nlines
, height
;
21519 /* %c and %l are ignored in `frame-title-format'. */
21520 if (mode_line_target
== MODE_LINE_TITLE
)
21523 startpos
= XMARKER (w
->start
)->charpos
;
21524 startpos_byte
= marker_byte_position (w
->start
);
21525 height
= WINDOW_TOTAL_LINES (w
);
21527 /* If we decided that this buffer isn't suitable for line numbers,
21528 don't forget that too fast. */
21529 if (EQ (w
->base_line_pos
, w
->buffer
))
21531 /* But do forget it, if the window shows a different buffer now. */
21532 else if (BUFFERP (w
->base_line_pos
))
21533 wset_base_line_pos (w
, Qnil
);
21535 /* If the buffer is very big, don't waste time. */
21536 if (INTEGERP (Vline_number_display_limit
)
21537 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
21539 wset_base_line_pos (w
, Qnil
);
21540 wset_base_line_number (w
, Qnil
);
21544 if (INTEGERP (w
->base_line_number
)
21545 && INTEGERP (w
->base_line_pos
)
21546 && XFASTINT (w
->base_line_pos
) <= startpos
)
21548 line
= XFASTINT (w
->base_line_number
);
21549 linepos
= XFASTINT (w
->base_line_pos
);
21550 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
21555 linepos
= BUF_BEGV (b
);
21556 linepos_byte
= BUF_BEGV_BYTE (b
);
21559 /* Count lines from base line to window start position. */
21560 nlines
= display_count_lines (linepos_byte
,
21564 topline
= nlines
+ line
;
21566 /* Determine a new base line, if the old one is too close
21567 or too far away, or if we did not have one.
21568 "Too close" means it's plausible a scroll-down would
21569 go back past it. */
21570 if (startpos
== BUF_BEGV (b
))
21572 wset_base_line_number (w
, make_number (topline
));
21573 wset_base_line_pos (w
, make_number (BUF_BEGV (b
)));
21575 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
21576 || linepos
== BUF_BEGV (b
))
21578 ptrdiff_t limit
= BUF_BEGV (b
);
21579 ptrdiff_t limit_byte
= BUF_BEGV_BYTE (b
);
21580 ptrdiff_t position
;
21581 ptrdiff_t distance
=
21582 (height
* 2 + 30) * line_number_display_limit_width
;
21584 if (startpos
- distance
> limit
)
21586 limit
= startpos
- distance
;
21587 limit_byte
= CHAR_TO_BYTE (limit
);
21590 nlines
= display_count_lines (startpos_byte
,
21592 - (height
* 2 + 30),
21594 /* If we couldn't find the lines we wanted within
21595 line_number_display_limit_width chars per line,
21596 give up on line numbers for this window. */
21597 if (position
== limit_byte
&& limit
== startpos
- distance
)
21599 wset_base_line_pos (w
, w
->buffer
);
21600 wset_base_line_number (w
, Qnil
);
21604 wset_base_line_number (w
, make_number (topline
- nlines
));
21605 wset_base_line_pos (w
, make_number (BYTE_TO_CHAR (position
)));
21608 /* Now count lines from the start pos to point. */
21609 nlines
= display_count_lines (startpos_byte
,
21610 PT_BYTE
, PT
, &junk
);
21612 /* Record that we did display the line number. */
21613 line_number_displayed
= 1;
21615 /* Make the string to show. */
21616 pint2str (decode_mode_spec_buf
, width
, topline
+ nlines
);
21617 return decode_mode_spec_buf
;
21620 char* p
= decode_mode_spec_buf
;
21621 int pad
= width
- 2;
21627 return decode_mode_spec_buf
;
21633 obj
= BVAR (b
, mode_name
);
21637 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
21643 ptrdiff_t pos
= marker_position (w
->start
);
21644 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
21646 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
21648 if (pos
<= BUF_BEGV (b
))
21653 else if (pos
<= BUF_BEGV (b
))
21657 if (total
> 1000000)
21658 /* Do it differently for a large value, to avoid overflow. */
21659 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
21661 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
21662 /* We can't normally display a 3-digit number,
21663 so get us a 2-digit number that is close. */
21666 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
21667 return decode_mode_spec_buf
;
21671 /* Display percentage of size above the bottom of the screen. */
21674 ptrdiff_t toppos
= marker_position (w
->start
);
21675 ptrdiff_t botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
21676 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
21678 if (botpos
>= BUF_ZV (b
))
21680 if (toppos
<= BUF_BEGV (b
))
21687 if (total
> 1000000)
21688 /* Do it differently for a large value, to avoid overflow. */
21689 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
21691 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
21692 /* We can't normally display a 3-digit number,
21693 so get us a 2-digit number that is close. */
21696 if (toppos
<= BUF_BEGV (b
))
21697 sprintf (decode_mode_spec_buf
, "Top%2"pD
"d%%", total
);
21699 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
21700 return decode_mode_spec_buf
;
21705 /* status of process */
21706 obj
= Fget_buffer_process (Fcurrent_buffer ());
21708 return "no process";
21710 obj
= Fsymbol_name (Fprocess_status (obj
));
21716 ptrdiff_t count
= inhibit_garbage_collection ();
21717 Lisp_Object val
= call1 (intern ("file-remote-p"),
21718 BVAR (current_buffer
, directory
));
21719 unbind_to (count
, Qnil
);
21727 case 't': /* indicate TEXT or BINARY */
21731 /* coding-system (not including end-of-line format) */
21733 /* coding-system (including end-of-line type) */
21735 int eol_flag
= (c
== 'Z');
21736 char *p
= decode_mode_spec_buf
;
21738 if (! FRAME_WINDOW_P (f
))
21740 /* No need to mention EOL here--the terminal never needs
21741 to do EOL conversion. */
21742 p
= decode_mode_spec_coding (CODING_ID_NAME
21743 (FRAME_KEYBOARD_CODING (f
)->id
),
21745 p
= decode_mode_spec_coding (CODING_ID_NAME
21746 (FRAME_TERMINAL_CODING (f
)->id
),
21749 p
= decode_mode_spec_coding (BVAR (b
, buffer_file_coding_system
),
21752 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
21753 #ifdef subprocesses
21754 obj
= Fget_buffer_process (Fcurrent_buffer ());
21755 if (PROCESSP (obj
))
21757 p
= decode_mode_spec_coding
21758 (XPROCESS (obj
)->decode_coding_system
, p
, eol_flag
);
21759 p
= decode_mode_spec_coding
21760 (XPROCESS (obj
)->encode_coding_system
, p
, eol_flag
);
21762 #endif /* subprocesses */
21765 return decode_mode_spec_buf
;
21772 return SSDATA (obj
);
21779 /* Count up to COUNT lines starting from START_BYTE.
21780 But don't go beyond LIMIT_BYTE.
21781 Return the number of lines thus found (always nonnegative).
21783 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
21786 display_count_lines (ptrdiff_t start_byte
,
21787 ptrdiff_t limit_byte
, ptrdiff_t count
,
21788 ptrdiff_t *byte_pos_ptr
)
21790 register unsigned char *cursor
;
21791 unsigned char *base
;
21793 register ptrdiff_t ceiling
;
21794 register unsigned char *ceiling_addr
;
21795 ptrdiff_t orig_count
= count
;
21797 /* If we are not in selective display mode,
21798 check only for newlines. */
21799 int selective_display
= (!NILP (BVAR (current_buffer
, selective_display
))
21800 && !INTEGERP (BVAR (current_buffer
, selective_display
)));
21804 while (start_byte
< limit_byte
)
21806 ceiling
= BUFFER_CEILING_OF (start_byte
);
21807 ceiling
= min (limit_byte
- 1, ceiling
);
21808 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
21809 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
21812 if (selective_display
)
21813 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
21816 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
21819 if (cursor
!= ceiling_addr
)
21823 start_byte
+= cursor
- base
+ 1;
21824 *byte_pos_ptr
= start_byte
;
21828 if (++cursor
== ceiling_addr
)
21834 start_byte
+= cursor
- base
;
21839 while (start_byte
> limit_byte
)
21841 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
21842 ceiling
= max (limit_byte
, ceiling
);
21843 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
21844 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
21847 if (selective_display
)
21848 while (--cursor
!= ceiling_addr
21849 && *cursor
!= '\n' && *cursor
!= 015)
21852 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
21855 if (cursor
!= ceiling_addr
)
21859 start_byte
+= cursor
- base
+ 1;
21860 *byte_pos_ptr
= start_byte
;
21861 /* When scanning backwards, we should
21862 not count the newline posterior to which we stop. */
21863 return - orig_count
- 1;
21869 /* Here we add 1 to compensate for the last decrement
21870 of CURSOR, which took it past the valid range. */
21871 start_byte
+= cursor
- base
+ 1;
21875 *byte_pos_ptr
= limit_byte
;
21878 return - orig_count
+ count
;
21879 return orig_count
- count
;
21885 /***********************************************************************
21887 ***********************************************************************/
21889 /* Display a NUL-terminated string, starting with index START.
21891 If STRING is non-null, display that C string. Otherwise, the Lisp
21892 string LISP_STRING is displayed. There's a case that STRING is
21893 non-null and LISP_STRING is not nil. It means STRING is a string
21894 data of LISP_STRING. In that case, we display LISP_STRING while
21895 ignoring its text properties.
21897 If FACE_STRING is not nil, FACE_STRING_POS is a position in
21898 FACE_STRING. Display STRING or LISP_STRING with the face at
21899 FACE_STRING_POS in FACE_STRING:
21901 Display the string in the environment given by IT, but use the
21902 standard display table, temporarily.
21904 FIELD_WIDTH is the minimum number of output glyphs to produce.
21905 If STRING has fewer characters than FIELD_WIDTH, pad to the right
21906 with spaces. If STRING has more characters, more than FIELD_WIDTH
21907 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
21909 PRECISION is the maximum number of characters to output from
21910 STRING. PRECISION < 0 means don't truncate the string.
21912 This is roughly equivalent to printf format specifiers:
21914 FIELD_WIDTH PRECISION PRINTF
21915 ----------------------------------------
21921 MULTIBYTE zero means do not display multibyte chars, > 0 means do
21922 display them, and < 0 means obey the current buffer's value of
21923 enable_multibyte_characters.
21925 Value is the number of columns displayed. */
21928 display_string (const char *string
, Lisp_Object lisp_string
, Lisp_Object face_string
,
21929 ptrdiff_t face_string_pos
, ptrdiff_t start
, struct it
*it
,
21930 int field_width
, int precision
, int max_x
, int multibyte
)
21932 int hpos_at_start
= it
->hpos
;
21933 int saved_face_id
= it
->face_id
;
21934 struct glyph_row
*row
= it
->glyph_row
;
21935 ptrdiff_t it_charpos
;
21937 /* Initialize the iterator IT for iteration over STRING beginning
21938 with index START. */
21939 reseat_to_string (it
, NILP (lisp_string
) ? string
: NULL
, lisp_string
, start
,
21940 precision
, field_width
, multibyte
);
21941 if (string
&& STRINGP (lisp_string
))
21942 /* LISP_STRING is the one returned by decode_mode_spec. We should
21943 ignore its text properties. */
21944 it
->stop_charpos
= it
->end_charpos
;
21946 /* If displaying STRING, set up the face of the iterator from
21947 FACE_STRING, if that's given. */
21948 if (STRINGP (face_string
))
21954 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
21955 0, it
->region_beg_charpos
,
21956 it
->region_end_charpos
,
21957 &endptr
, it
->base_face_id
, 0);
21958 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
21959 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
21962 /* Set max_x to the maximum allowed X position. Don't let it go
21963 beyond the right edge of the window. */
21965 max_x
= it
->last_visible_x
;
21967 max_x
= min (max_x
, it
->last_visible_x
);
21969 /* Skip over display elements that are not visible. because IT->w is
21971 if (it
->current_x
< it
->first_visible_x
)
21972 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
21973 MOVE_TO_POS
| MOVE_TO_X
);
21975 row
->ascent
= it
->max_ascent
;
21976 row
->height
= it
->max_ascent
+ it
->max_descent
;
21977 row
->phys_ascent
= it
->max_phys_ascent
;
21978 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
21979 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
21981 if (STRINGP (it
->string
))
21982 it_charpos
= IT_STRING_CHARPOS (*it
);
21984 it_charpos
= IT_CHARPOS (*it
);
21986 /* This condition is for the case that we are called with current_x
21987 past last_visible_x. */
21988 while (it
->current_x
< max_x
)
21990 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
21992 /* Get the next display element. */
21993 if (!get_next_display_element (it
))
21996 /* Produce glyphs. */
21997 x_before
= it
->current_x
;
21998 n_glyphs_before
= row
->used
[TEXT_AREA
];
21999 PRODUCE_GLYPHS (it
);
22001 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
22004 while (i
< nglyphs
)
22006 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
22008 if (it
->line_wrap
!= TRUNCATE
22009 && x
+ glyph
->pixel_width
> max_x
)
22011 /* End of continued line or max_x reached. */
22012 if (CHAR_GLYPH_PADDING_P (*glyph
))
22014 /* A wide character is unbreakable. */
22015 if (row
->reversed_p
)
22016 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
22017 - n_glyphs_before
);
22018 row
->used
[TEXT_AREA
] = n_glyphs_before
;
22019 it
->current_x
= x_before
;
22023 if (row
->reversed_p
)
22024 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
22025 - (n_glyphs_before
+ i
));
22026 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
22031 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
22033 /* Glyph is at least partially visible. */
22035 if (x
< it
->first_visible_x
)
22036 row
->x
= x
- it
->first_visible_x
;
22040 /* Glyph is off the left margin of the display area.
22041 Should not happen. */
22045 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
22046 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
22047 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
22048 row
->phys_height
= max (row
->phys_height
,
22049 it
->max_phys_ascent
+ it
->max_phys_descent
);
22050 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
22051 it
->max_extra_line_spacing
);
22052 x
+= glyph
->pixel_width
;
22056 /* Stop if max_x reached. */
22060 /* Stop at line ends. */
22061 if (ITERATOR_AT_END_OF_LINE_P (it
))
22063 it
->continuation_lines_width
= 0;
22067 set_iterator_to_next (it
, 1);
22068 if (STRINGP (it
->string
))
22069 it_charpos
= IT_STRING_CHARPOS (*it
);
22071 it_charpos
= IT_CHARPOS (*it
);
22073 /* Stop if truncating at the right edge. */
22074 if (it
->line_wrap
== TRUNCATE
22075 && it
->current_x
>= it
->last_visible_x
)
22077 /* Add truncation mark, but don't do it if the line is
22078 truncated at a padding space. */
22079 if (it_charpos
< it
->string_nchars
)
22081 if (!FRAME_WINDOW_P (it
->f
))
22085 if (it
->current_x
> it
->last_visible_x
)
22087 if (!row
->reversed_p
)
22089 for (ii
= row
->used
[TEXT_AREA
] - 1; ii
> 0; --ii
)
22090 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
22095 for (ii
= 0; ii
< row
->used
[TEXT_AREA
]; ii
++)
22096 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
22098 unproduce_glyphs (it
, ii
+ 1);
22099 ii
= row
->used
[TEXT_AREA
] - (ii
+ 1);
22101 for (n
= row
->used
[TEXT_AREA
]; ii
< n
; ++ii
)
22103 row
->used
[TEXT_AREA
] = ii
;
22104 produce_special_glyphs (it
, IT_TRUNCATION
);
22107 produce_special_glyphs (it
, IT_TRUNCATION
);
22109 row
->truncated_on_right_p
= 1;
22115 /* Maybe insert a truncation at the left. */
22116 if (it
->first_visible_x
22119 if (!FRAME_WINDOW_P (it
->f
)
22120 || (row
->reversed_p
22121 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
22122 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
22123 insert_left_trunc_glyphs (it
);
22124 row
->truncated_on_left_p
= 1;
22127 it
->face_id
= saved_face_id
;
22129 /* Value is number of columns displayed. */
22130 return it
->hpos
- hpos_at_start
;
22135 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
22136 appears as an element of LIST or as the car of an element of LIST.
22137 If PROPVAL is a list, compare each element against LIST in that
22138 way, and return 1/2 if any element of PROPVAL is found in LIST.
22139 Otherwise return 0. This function cannot quit.
22140 The return value is 2 if the text is invisible but with an ellipsis
22141 and 1 if it's invisible and without an ellipsis. */
22144 invisible_p (register Lisp_Object propval
, Lisp_Object list
)
22146 register Lisp_Object tail
, proptail
;
22148 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
22150 register Lisp_Object tem
;
22152 if (EQ (propval
, tem
))
22154 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
22155 return NILP (XCDR (tem
)) ? 1 : 2;
22158 if (CONSP (propval
))
22160 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
22162 Lisp_Object propelt
;
22163 propelt
= XCAR (proptail
);
22164 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
22166 register Lisp_Object tem
;
22168 if (EQ (propelt
, tem
))
22170 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
22171 return NILP (XCDR (tem
)) ? 1 : 2;
22179 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
22180 doc
: /* Non-nil if the property makes the text invisible.
22181 POS-OR-PROP can be a marker or number, in which case it is taken to be
22182 a position in the current buffer and the value of the `invisible' property
22183 is checked; or it can be some other value, which is then presumed to be the
22184 value of the `invisible' property of the text of interest.
22185 The non-nil value returned can be t for truly invisible text or something
22186 else if the text is replaced by an ellipsis. */)
22187 (Lisp_Object pos_or_prop
)
22190 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
22191 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
22193 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
22194 return (invis
== 0 ? Qnil
22196 : make_number (invis
));
22199 /* Calculate a width or height in pixels from a specification using
22200 the following elements:
22203 NUM - a (fractional) multiple of the default font width/height
22204 (NUM) - specifies exactly NUM pixels
22205 UNIT - a fixed number of pixels, see below.
22206 ELEMENT - size of a display element in pixels, see below.
22207 (NUM . SPEC) - equals NUM * SPEC
22208 (+ SPEC SPEC ...) - add pixel values
22209 (- SPEC SPEC ...) - subtract pixel values
22210 (- SPEC) - negate pixel value
22213 INT or FLOAT - a number constant
22214 SYMBOL - use symbol's (buffer local) variable binding.
22217 in - pixels per inch *)
22218 mm - pixels per 1/1000 meter *)
22219 cm - pixels per 1/100 meter *)
22220 width - width of current font in pixels.
22221 height - height of current font in pixels.
22223 *) using the ratio(s) defined in display-pixels-per-inch.
22227 left-fringe - left fringe width in pixels
22228 right-fringe - right fringe width in pixels
22230 left-margin - left margin width in pixels
22231 right-margin - right margin width in pixels
22233 scroll-bar - scroll-bar area width in pixels
22237 Pixels corresponding to 5 inches:
22240 Total width of non-text areas on left side of window (if scroll-bar is on left):
22241 '(space :width (+ left-fringe left-margin scroll-bar))
22243 Align to first text column (in header line):
22244 '(space :align-to 0)
22246 Align to middle of text area minus half the width of variable `my-image'
22247 containing a loaded image:
22248 '(space :align-to (0.5 . (- text my-image)))
22250 Width of left margin minus width of 1 character in the default font:
22251 '(space :width (- left-margin 1))
22253 Width of left margin minus width of 2 characters in the current font:
22254 '(space :width (- left-margin (2 . width)))
22256 Center 1 character over left-margin (in header line):
22257 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
22259 Different ways to express width of left fringe plus left margin minus one pixel:
22260 '(space :width (- (+ left-fringe left-margin) (1)))
22261 '(space :width (+ left-fringe left-margin (- (1))))
22262 '(space :width (+ left-fringe left-margin (-1)))
22266 #define NUMVAL(X) \
22267 ((INTEGERP (X) || FLOATP (X)) \
22272 calc_pixel_width_or_height (double *res
, struct it
*it
, Lisp_Object prop
,
22273 struct font
*font
, int width_p
, int *align_to
)
22277 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
22278 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
22281 return OK_PIXELS (0);
22283 eassert (FRAME_LIVE_P (it
->f
));
22285 if (SYMBOLP (prop
))
22287 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
22289 char *unit
= SSDATA (SYMBOL_NAME (prop
));
22291 if (unit
[0] == 'i' && unit
[1] == 'n')
22293 else if (unit
[0] == 'm' && unit
[1] == 'm')
22295 else if (unit
[0] == 'c' && unit
[1] == 'm')
22302 #ifdef HAVE_WINDOW_SYSTEM
22303 if (FRAME_WINDOW_P (it
->f
)
22305 ? FRAME_X_DISPLAY_INFO (it
->f
)->resx
22306 : FRAME_X_DISPLAY_INFO (it
->f
)->resy
),
22308 return OK_PIXELS (ppi
/ pixels
);
22311 if ((ppi
= NUMVAL (Vdisplay_pixels_per_inch
), ppi
> 0)
22312 || (CONSP (Vdisplay_pixels_per_inch
)
22314 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch
))
22315 : NUMVAL (XCDR (Vdisplay_pixels_per_inch
))),
22317 return OK_PIXELS (ppi
/ pixels
);
22323 #ifdef HAVE_WINDOW_SYSTEM
22324 if (EQ (prop
, Qheight
))
22325 return OK_PIXELS (font
? FONT_HEIGHT (font
) : FRAME_LINE_HEIGHT (it
->f
));
22326 if (EQ (prop
, Qwidth
))
22327 return OK_PIXELS (font
? FONT_WIDTH (font
) : FRAME_COLUMN_WIDTH (it
->f
));
22329 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
22330 return OK_PIXELS (1);
22333 if (EQ (prop
, Qtext
))
22334 return OK_PIXELS (width_p
22335 ? window_box_width (it
->w
, TEXT_AREA
)
22336 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
22338 if (align_to
&& *align_to
< 0)
22341 if (EQ (prop
, Qleft
))
22342 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
22343 if (EQ (prop
, Qright
))
22344 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
22345 if (EQ (prop
, Qcenter
))
22346 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
22347 + window_box_width (it
->w
, TEXT_AREA
) / 2);
22348 if (EQ (prop
, Qleft_fringe
))
22349 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22350 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
22351 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
22352 if (EQ (prop
, Qright_fringe
))
22353 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22354 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
22355 : window_box_right_offset (it
->w
, TEXT_AREA
));
22356 if (EQ (prop
, Qleft_margin
))
22357 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
22358 if (EQ (prop
, Qright_margin
))
22359 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
22360 if (EQ (prop
, Qscroll_bar
))
22361 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
22363 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
22364 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22365 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
22370 if (EQ (prop
, Qleft_fringe
))
22371 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
22372 if (EQ (prop
, Qright_fringe
))
22373 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
22374 if (EQ (prop
, Qleft_margin
))
22375 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
22376 if (EQ (prop
, Qright_margin
))
22377 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
22378 if (EQ (prop
, Qscroll_bar
))
22379 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
22382 prop
= buffer_local_value_1 (prop
, it
->w
->buffer
);
22383 if (EQ (prop
, Qunbound
))
22387 if (INTEGERP (prop
) || FLOATP (prop
))
22389 int base_unit
= (width_p
22390 ? FRAME_COLUMN_WIDTH (it
->f
)
22391 : FRAME_LINE_HEIGHT (it
->f
));
22392 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
22397 Lisp_Object car
= XCAR (prop
);
22398 Lisp_Object cdr
= XCDR (prop
);
22402 #ifdef HAVE_WINDOW_SYSTEM
22403 if (FRAME_WINDOW_P (it
->f
)
22404 && valid_image_p (prop
))
22406 ptrdiff_t id
= lookup_image (it
->f
, prop
);
22407 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
22409 return OK_PIXELS (width_p
? img
->width
: img
->height
);
22412 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
22418 while (CONSP (cdr
))
22420 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
22421 font
, width_p
, align_to
))
22424 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
22429 if (EQ (car
, Qminus
))
22431 return OK_PIXELS (pixels
);
22434 car
= buffer_local_value_1 (car
, it
->w
->buffer
);
22435 if (EQ (car
, Qunbound
))
22439 if (INTEGERP (car
) || FLOATP (car
))
22442 pixels
= XFLOATINT (car
);
22444 return OK_PIXELS (pixels
);
22445 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
22446 font
, width_p
, align_to
))
22447 return OK_PIXELS (pixels
* fact
);
22458 /***********************************************************************
22460 ***********************************************************************/
22462 #ifdef HAVE_WINDOW_SYSTEM
22467 dump_glyph_string (struct glyph_string
*s
)
22469 fprintf (stderr
, "glyph string\n");
22470 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
22471 s
->x
, s
->y
, s
->width
, s
->height
);
22472 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
22473 fprintf (stderr
, " hl = %d\n", s
->hl
);
22474 fprintf (stderr
, " left overhang = %d, right = %d\n",
22475 s
->left_overhang
, s
->right_overhang
);
22476 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
22477 fprintf (stderr
, " extends to end of line = %d\n",
22478 s
->extends_to_end_of_line_p
);
22479 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
22480 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
22483 #endif /* GLYPH_DEBUG */
22485 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
22486 of XChar2b structures for S; it can't be allocated in
22487 init_glyph_string because it must be allocated via `alloca'. W
22488 is the window on which S is drawn. ROW and AREA are the glyph row
22489 and area within the row from which S is constructed. START is the
22490 index of the first glyph structure covered by S. HL is a
22491 face-override for drawing S. */
22494 #define OPTIONAL_HDC(hdc) HDC hdc,
22495 #define DECLARE_HDC(hdc) HDC hdc;
22496 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
22497 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
22500 #ifndef OPTIONAL_HDC
22501 #define OPTIONAL_HDC(hdc)
22502 #define DECLARE_HDC(hdc)
22503 #define ALLOCATE_HDC(hdc, f)
22504 #define RELEASE_HDC(hdc, f)
22508 init_glyph_string (struct glyph_string
*s
,
22510 XChar2b
*char2b
, struct window
*w
, struct glyph_row
*row
,
22511 enum glyph_row_area area
, int start
, enum draw_glyphs_face hl
)
22513 memset (s
, 0, sizeof *s
);
22515 s
->f
= XFRAME (w
->frame
);
22519 s
->display
= FRAME_X_DISPLAY (s
->f
);
22520 s
->window
= FRAME_X_WINDOW (s
->f
);
22521 s
->char2b
= char2b
;
22525 s
->first_glyph
= row
->glyphs
[area
] + start
;
22526 s
->height
= row
->height
;
22527 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
22528 s
->ybase
= s
->y
+ row
->ascent
;
22532 /* Append the list of glyph strings with head H and tail T to the list
22533 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
22536 append_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
22537 struct glyph_string
*h
, struct glyph_string
*t
)
22551 /* Prepend the list of glyph strings with head H and tail T to the
22552 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
22556 prepend_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
22557 struct glyph_string
*h
, struct glyph_string
*t
)
22571 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
22572 Set *HEAD and *TAIL to the resulting list. */
22575 append_glyph_string (struct glyph_string
**head
, struct glyph_string
**tail
,
22576 struct glyph_string
*s
)
22578 s
->next
= s
->prev
= NULL
;
22579 append_glyph_string_lists (head
, tail
, s
, s
);
22583 /* Get face and two-byte form of character C in face FACE_ID on frame F.
22584 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
22585 make sure that X resources for the face returned are allocated.
22586 Value is a pointer to a realized face that is ready for display if
22587 DISPLAY_P is non-zero. */
22589 static struct face
*
22590 get_char_face_and_encoding (struct frame
*f
, int c
, int face_id
,
22591 XChar2b
*char2b
, int display_p
)
22593 struct face
*face
= FACE_FROM_ID (f
, face_id
);
22597 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
22599 if (code
!= FONT_INVALID_CODE
)
22600 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22602 STORE_XCHAR2B (char2b
, 0, 0);
22605 /* Make sure X resources of the face are allocated. */
22606 #ifdef HAVE_X_WINDOWS
22610 eassert (face
!= NULL
);
22611 PREPARE_FACE_FOR_DISPLAY (f
, face
);
22618 /* Get face and two-byte form of character glyph GLYPH on frame F.
22619 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
22620 a pointer to a realized face that is ready for display. */
22622 static struct face
*
22623 get_glyph_face_and_encoding (struct frame
*f
, struct glyph
*glyph
,
22624 XChar2b
*char2b
, int *two_byte_p
)
22628 eassert (glyph
->type
== CHAR_GLYPH
);
22629 face
= FACE_FROM_ID (f
, glyph
->face_id
);
22638 if (CHAR_BYTE8_P (glyph
->u
.ch
))
22639 code
= CHAR_TO_BYTE8 (glyph
->u
.ch
);
22641 code
= face
->font
->driver
->encode_char (face
->font
, glyph
->u
.ch
);
22643 if (code
!= FONT_INVALID_CODE
)
22644 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22646 STORE_XCHAR2B (char2b
, 0, 0);
22649 /* Make sure X resources of the face are allocated. */
22650 eassert (face
!= NULL
);
22651 PREPARE_FACE_FOR_DISPLAY (f
, face
);
22656 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
22657 Return 1 if FONT has a glyph for C, otherwise return 0. */
22660 get_char_glyph_code (int c
, struct font
*font
, XChar2b
*char2b
)
22664 if (CHAR_BYTE8_P (c
))
22665 code
= CHAR_TO_BYTE8 (c
);
22667 code
= font
->driver
->encode_char (font
, c
);
22669 if (code
== FONT_INVALID_CODE
)
22671 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22676 /* Fill glyph string S with composition components specified by S->cmp.
22678 BASE_FACE is the base face of the composition.
22679 S->cmp_from is the index of the first component for S.
22681 OVERLAPS non-zero means S should draw the foreground only, and use
22682 its physical height for clipping. See also draw_glyphs.
22684 Value is the index of a component not in S. */
22687 fill_composite_glyph_string (struct glyph_string
*s
, struct face
*base_face
,
22691 /* For all glyphs of this composition, starting at the offset
22692 S->cmp_from, until we reach the end of the definition or encounter a
22693 glyph that requires the different face, add it to S. */
22698 s
->for_overlaps
= overlaps
;
22701 for (i
= s
->cmp_from
; i
< s
->cmp
->glyph_len
; i
++)
22703 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
22705 /* TAB in a composition means display glyphs with padding space
22706 on the left or right. */
22709 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
->ascii_face
, c
,
22712 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
22719 s
->font
= s
->face
->font
;
22721 else if (s
->face
!= face
)
22729 if (s
->face
== NULL
)
22731 s
->face
= base_face
->ascii_face
;
22732 s
->font
= s
->face
->font
;
22735 /* All glyph strings for the same composition has the same width,
22736 i.e. the width set for the first component of the composition. */
22737 s
->width
= s
->first_glyph
->pixel_width
;
22739 /* If the specified font could not be loaded, use the frame's
22740 default font, but record the fact that we couldn't load it in
22741 the glyph string so that we can draw rectangles for the
22742 characters of the glyph string. */
22743 if (s
->font
== NULL
)
22745 s
->font_not_found_p
= 1;
22746 s
->font
= FRAME_FONT (s
->f
);
22749 /* Adjust base line for subscript/superscript text. */
22750 s
->ybase
+= s
->first_glyph
->voffset
;
22752 /* This glyph string must always be drawn with 16-bit functions. */
22759 fill_gstring_glyph_string (struct glyph_string
*s
, int face_id
,
22760 int start
, int end
, int overlaps
)
22762 struct glyph
*glyph
, *last
;
22763 Lisp_Object lgstring
;
22766 s
->for_overlaps
= overlaps
;
22767 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22768 last
= s
->row
->glyphs
[s
->area
] + end
;
22769 s
->cmp_id
= glyph
->u
.cmp
.id
;
22770 s
->cmp_from
= glyph
->slice
.cmp
.from
;
22771 s
->cmp_to
= glyph
->slice
.cmp
.to
+ 1;
22772 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22773 lgstring
= composition_gstring_from_id (s
->cmp_id
);
22774 s
->font
= XFONT_OBJECT (LGSTRING_FONT (lgstring
));
22776 while (glyph
< last
22777 && glyph
->u
.cmp
.automatic
22778 && glyph
->u
.cmp
.id
== s
->cmp_id
22779 && s
->cmp_to
== glyph
->slice
.cmp
.from
)
22780 s
->cmp_to
= (glyph
++)->slice
.cmp
.to
+ 1;
22782 for (i
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
22784 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
22785 unsigned code
= LGLYPH_CODE (lglyph
);
22787 STORE_XCHAR2B ((s
->char2b
+ i
), code
>> 8, code
& 0xFF);
22789 s
->width
= composition_gstring_width (lgstring
, s
->cmp_from
, s
->cmp_to
, NULL
);
22790 return glyph
- s
->row
->glyphs
[s
->area
];
22794 /* Fill glyph string S from a sequence glyphs for glyphless characters.
22795 See the comment of fill_glyph_string for arguments.
22796 Value is the index of the first glyph not in S. */
22800 fill_glyphless_glyph_string (struct glyph_string
*s
, int face_id
,
22801 int start
, int end
, int overlaps
)
22803 struct glyph
*glyph
, *last
;
22806 eassert (s
->first_glyph
->type
== GLYPHLESS_GLYPH
);
22807 s
->for_overlaps
= overlaps
;
22808 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22809 last
= s
->row
->glyphs
[s
->area
] + end
;
22810 voffset
= glyph
->voffset
;
22811 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22812 s
->font
= s
->face
->font
? s
->face
->font
: FRAME_FONT (s
->f
);
22814 s
->width
= glyph
->pixel_width
;
22816 while (glyph
< last
22817 && glyph
->type
== GLYPHLESS_GLYPH
22818 && glyph
->voffset
== voffset
22819 && glyph
->face_id
== face_id
)
22822 s
->width
+= glyph
->pixel_width
;
22825 s
->ybase
+= voffset
;
22826 return glyph
- s
->row
->glyphs
[s
->area
];
22830 /* Fill glyph string S from a sequence of character glyphs.
22832 FACE_ID is the face id of the string. START is the index of the
22833 first glyph to consider, END is the index of the last + 1.
22834 OVERLAPS non-zero means S should draw the foreground only, and use
22835 its physical height for clipping. See also draw_glyphs.
22837 Value is the index of the first glyph not in S. */
22840 fill_glyph_string (struct glyph_string
*s
, int face_id
,
22841 int start
, int end
, int overlaps
)
22843 struct glyph
*glyph
, *last
;
22845 int glyph_not_available_p
;
22847 eassert (s
->f
== XFRAME (s
->w
->frame
));
22848 eassert (s
->nchars
== 0);
22849 eassert (start
>= 0 && end
> start
);
22851 s
->for_overlaps
= overlaps
;
22852 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22853 last
= s
->row
->glyphs
[s
->area
] + end
;
22854 voffset
= glyph
->voffset
;
22855 s
->padding_p
= glyph
->padding_p
;
22856 glyph_not_available_p
= glyph
->glyph_not_available_p
;
22858 while (glyph
< last
22859 && glyph
->type
== CHAR_GLYPH
22860 && glyph
->voffset
== voffset
22861 /* Same face id implies same font, nowadays. */
22862 && glyph
->face_id
== face_id
22863 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
22867 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
22868 s
->char2b
+ s
->nchars
,
22870 s
->two_byte_p
= two_byte_p
;
22872 eassert (s
->nchars
<= end
- start
);
22873 s
->width
+= glyph
->pixel_width
;
22874 if (glyph
++->padding_p
!= s
->padding_p
)
22878 s
->font
= s
->face
->font
;
22880 /* If the specified font could not be loaded, use the frame's font,
22881 but record the fact that we couldn't load it in
22882 S->font_not_found_p so that we can draw rectangles for the
22883 characters of the glyph string. */
22884 if (s
->font
== NULL
|| glyph_not_available_p
)
22886 s
->font_not_found_p
= 1;
22887 s
->font
= FRAME_FONT (s
->f
);
22890 /* Adjust base line for subscript/superscript text. */
22891 s
->ybase
+= voffset
;
22893 eassert (s
->face
&& s
->face
->gc
);
22894 return glyph
- s
->row
->glyphs
[s
->area
];
22898 /* Fill glyph string S from image glyph S->first_glyph. */
22901 fill_image_glyph_string (struct glyph_string
*s
)
22903 eassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
22904 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
22906 s
->slice
= s
->first_glyph
->slice
.img
;
22907 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
22908 s
->font
= s
->face
->font
;
22909 s
->width
= s
->first_glyph
->pixel_width
;
22911 /* Adjust base line for subscript/superscript text. */
22912 s
->ybase
+= s
->first_glyph
->voffset
;
22916 /* Fill glyph string S from a sequence of stretch glyphs.
22918 START is the index of the first glyph to consider,
22919 END is the index of the last + 1.
22921 Value is the index of the first glyph not in S. */
22924 fill_stretch_glyph_string (struct glyph_string
*s
, int start
, int end
)
22926 struct glyph
*glyph
, *last
;
22927 int voffset
, face_id
;
22929 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
22931 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22932 last
= s
->row
->glyphs
[s
->area
] + end
;
22933 face_id
= glyph
->face_id
;
22934 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22935 s
->font
= s
->face
->font
;
22936 s
->width
= glyph
->pixel_width
;
22938 voffset
= glyph
->voffset
;
22942 && glyph
->type
== STRETCH_GLYPH
22943 && glyph
->voffset
== voffset
22944 && glyph
->face_id
== face_id
);
22946 s
->width
+= glyph
->pixel_width
;
22948 /* Adjust base line for subscript/superscript text. */
22949 s
->ybase
+= voffset
;
22951 /* The case that face->gc == 0 is handled when drawing the glyph
22952 string by calling PREPARE_FACE_FOR_DISPLAY. */
22954 return glyph
- s
->row
->glyphs
[s
->area
];
22957 static struct font_metrics
*
22958 get_per_char_metric (struct font
*font
, XChar2b
*char2b
)
22960 static struct font_metrics metrics
;
22961 unsigned code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
22963 if (! font
|| code
== FONT_INVALID_CODE
)
22965 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
22970 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
22971 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
22972 assumed to be zero. */
22975 x_get_glyph_overhangs (struct glyph
*glyph
, struct frame
*f
, int *left
, int *right
)
22977 *left
= *right
= 0;
22979 if (glyph
->type
== CHAR_GLYPH
)
22983 struct font_metrics
*pcm
;
22985 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
22986 if (face
->font
&& (pcm
= get_per_char_metric (face
->font
, &char2b
)))
22988 if (pcm
->rbearing
> pcm
->width
)
22989 *right
= pcm
->rbearing
- pcm
->width
;
22990 if (pcm
->lbearing
< 0)
22991 *left
= -pcm
->lbearing
;
22994 else if (glyph
->type
== COMPOSITE_GLYPH
)
22996 if (! glyph
->u
.cmp
.automatic
)
22998 struct composition
*cmp
= composition_table
[glyph
->u
.cmp
.id
];
23000 if (cmp
->rbearing
> cmp
->pixel_width
)
23001 *right
= cmp
->rbearing
- cmp
->pixel_width
;
23002 if (cmp
->lbearing
< 0)
23003 *left
= - cmp
->lbearing
;
23007 Lisp_Object gstring
= composition_gstring_from_id (glyph
->u
.cmp
.id
);
23008 struct font_metrics metrics
;
23010 composition_gstring_width (gstring
, glyph
->slice
.cmp
.from
,
23011 glyph
->slice
.cmp
.to
+ 1, &metrics
);
23012 if (metrics
.rbearing
> metrics
.width
)
23013 *right
= metrics
.rbearing
- metrics
.width
;
23014 if (metrics
.lbearing
< 0)
23015 *left
= - metrics
.lbearing
;
23021 /* Return the index of the first glyph preceding glyph string S that
23022 is overwritten by S because of S's left overhang. Value is -1
23023 if no glyphs are overwritten. */
23026 left_overwritten (struct glyph_string
*s
)
23030 if (s
->left_overhang
)
23033 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23034 int first
= s
->first_glyph
- glyphs
;
23036 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
23037 x
-= glyphs
[i
].pixel_width
;
23048 /* Return the index of the first glyph preceding glyph string S that
23049 is overwriting S because of its right overhang. Value is -1 if no
23050 glyph in front of S overwrites S. */
23053 left_overwriting (struct glyph_string
*s
)
23056 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23057 int first
= s
->first_glyph
- glyphs
;
23061 for (i
= first
- 1; i
>= 0; --i
)
23064 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
23067 x
-= glyphs
[i
].pixel_width
;
23074 /* Return the index of the last glyph following glyph string S that is
23075 overwritten by S because of S's right overhang. Value is -1 if
23076 no such glyph is found. */
23079 right_overwritten (struct glyph_string
*s
)
23083 if (s
->right_overhang
)
23086 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23087 int first
= (s
->first_glyph
- glyphs
23088 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
23089 int end
= s
->row
->used
[s
->area
];
23091 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
23092 x
+= glyphs
[i
].pixel_width
;
23101 /* Return the index of the last glyph following glyph string S that
23102 overwrites S because of its left overhang. Value is negative
23103 if no such glyph is found. */
23106 right_overwriting (struct glyph_string
*s
)
23109 int end
= s
->row
->used
[s
->area
];
23110 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23111 int first
= (s
->first_glyph
- glyphs
23112 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
23116 for (i
= first
; i
< end
; ++i
)
23119 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
23122 x
+= glyphs
[i
].pixel_width
;
23129 /* Set background width of glyph string S. START is the index of the
23130 first glyph following S. LAST_X is the right-most x-position + 1
23131 in the drawing area. */
23134 set_glyph_string_background_width (struct glyph_string
*s
, int start
, int last_x
)
23136 /* If the face of this glyph string has to be drawn to the end of
23137 the drawing area, set S->extends_to_end_of_line_p. */
23139 if (start
== s
->row
->used
[s
->area
]
23140 && s
->area
== TEXT_AREA
23141 && ((s
->row
->fill_line_p
23142 && (s
->hl
== DRAW_NORMAL_TEXT
23143 || s
->hl
== DRAW_IMAGE_RAISED
23144 || s
->hl
== DRAW_IMAGE_SUNKEN
))
23145 || s
->hl
== DRAW_MOUSE_FACE
))
23146 s
->extends_to_end_of_line_p
= 1;
23148 /* If S extends its face to the end of the line, set its
23149 background_width to the distance to the right edge of the drawing
23151 if (s
->extends_to_end_of_line_p
)
23152 s
->background_width
= last_x
- s
->x
+ 1;
23154 s
->background_width
= s
->width
;
23158 /* Compute overhangs and x-positions for glyph string S and its
23159 predecessors, or successors. X is the starting x-position for S.
23160 BACKWARD_P non-zero means process predecessors. */
23163 compute_overhangs_and_x (struct glyph_string
*s
, int x
, int backward_p
)
23169 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
23170 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
23180 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
23181 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
23191 /* The following macros are only called from draw_glyphs below.
23192 They reference the following parameters of that function directly:
23193 `w', `row', `area', and `overlap_p'
23194 as well as the following local variables:
23195 `s', `f', and `hdc' (in W32) */
23198 /* On W32, silently add local `hdc' variable to argument list of
23199 init_glyph_string. */
23200 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
23201 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
23203 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
23204 init_glyph_string (s, char2b, w, row, area, start, hl)
23207 /* Add a glyph string for a stretch glyph to the list of strings
23208 between HEAD and TAIL. START is the index of the stretch glyph in
23209 row area AREA of glyph row ROW. END is the index of the last glyph
23210 in that glyph row area. X is the current output position assigned
23211 to the new glyph string constructed. HL overrides that face of the
23212 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
23213 is the right-most x-position of the drawing area. */
23215 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
23216 and below -- keep them on one line. */
23217 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23220 s = alloca (sizeof *s); \
23221 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23222 START = fill_stretch_glyph_string (s, START, END); \
23223 append_glyph_string (&HEAD, &TAIL, s); \
23229 /* Add a glyph string for an image glyph to the list of strings
23230 between HEAD and TAIL. START is the index of the image glyph in
23231 row area AREA of glyph row ROW. END is the index of the last glyph
23232 in that glyph row area. X is the current output position assigned
23233 to the new glyph string constructed. HL overrides that face of the
23234 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
23235 is the right-most x-position of the drawing area. */
23237 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23240 s = alloca (sizeof *s); \
23241 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23242 fill_image_glyph_string (s); \
23243 append_glyph_string (&HEAD, &TAIL, s); \
23250 /* Add a glyph string for a sequence of character glyphs to the list
23251 of strings between HEAD and TAIL. START is the index of the first
23252 glyph in row area AREA of glyph row ROW that is part of the new
23253 glyph string. END is the index of the last glyph in that glyph row
23254 area. X is the current output position assigned to the new glyph
23255 string constructed. HL overrides that face of the glyph; e.g. it
23256 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
23257 right-most x-position of the drawing area. */
23259 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
23265 face_id = (row)->glyphs[area][START].face_id; \
23267 s = alloca (sizeof *s); \
23268 char2b = alloca ((END - START) * sizeof *char2b); \
23269 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23270 append_glyph_string (&HEAD, &TAIL, s); \
23272 START = fill_glyph_string (s, face_id, START, END, overlaps); \
23277 /* Add a glyph string for a composite sequence to the list of strings
23278 between HEAD and TAIL. START is the index of the first glyph in
23279 row area AREA of glyph row ROW that is part of the new glyph
23280 string. END is the index of the last glyph in that glyph row area.
23281 X is the current output position assigned to the new glyph string
23282 constructed. HL overrides that face of the glyph; e.g. it is
23283 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
23284 x-position of the drawing area. */
23286 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23288 int face_id = (row)->glyphs[area][START].face_id; \
23289 struct face *base_face = FACE_FROM_ID (f, face_id); \
23290 ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id; \
23291 struct composition *cmp = composition_table[cmp_id]; \
23293 struct glyph_string *first_s = NULL; \
23296 char2b = alloca (cmp->glyph_len * sizeof *char2b); \
23298 /* Make glyph_strings for each glyph sequence that is drawable by \
23299 the same face, and append them to HEAD/TAIL. */ \
23300 for (n = 0; n < cmp->glyph_len;) \
23302 s = alloca (sizeof *s); \
23303 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23304 append_glyph_string (&(HEAD), &(TAIL), s); \
23310 n = fill_composite_glyph_string (s, base_face, overlaps); \
23318 /* Add a glyph string for a glyph-string sequence to the list of strings
23319 between HEAD and TAIL. */
23321 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23325 Lisp_Object gstring; \
23327 face_id = (row)->glyphs[area][START].face_id; \
23328 gstring = (composition_gstring_from_id \
23329 ((row)->glyphs[area][START].u.cmp.id)); \
23330 s = alloca (sizeof *s); \
23331 char2b = alloca (LGSTRING_GLYPH_LEN (gstring) * sizeof *char2b); \
23332 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23333 append_glyph_string (&(HEAD), &(TAIL), s); \
23335 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
23339 /* Add a glyph string for a sequence of glyphless character's glyphs
23340 to the list of strings between HEAD and TAIL. The meanings of
23341 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
23343 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23348 face_id = (row)->glyphs[area][START].face_id; \
23350 s = alloca (sizeof *s); \
23351 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23352 append_glyph_string (&HEAD, &TAIL, s); \
23354 START = fill_glyphless_glyph_string (s, face_id, START, END, \
23360 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
23361 of AREA of glyph row ROW on window W between indices START and END.
23362 HL overrides the face for drawing glyph strings, e.g. it is
23363 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
23364 x-positions of the drawing area.
23366 This is an ugly monster macro construct because we must use alloca
23367 to allocate glyph strings (because draw_glyphs can be called
23368 asynchronously). */
23370 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
23373 HEAD = TAIL = NULL; \
23374 while (START < END) \
23376 struct glyph *first_glyph = (row)->glyphs[area] + START; \
23377 switch (first_glyph->type) \
23380 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
23384 case COMPOSITE_GLYPH: \
23385 if (first_glyph->u.cmp.automatic) \
23386 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
23389 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
23393 case STRETCH_GLYPH: \
23394 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
23398 case IMAGE_GLYPH: \
23399 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
23403 case GLYPHLESS_GLYPH: \
23404 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
23414 set_glyph_string_background_width (s, START, LAST_X); \
23421 /* Draw glyphs between START and END in AREA of ROW on window W,
23422 starting at x-position X. X is relative to AREA in W. HL is a
23423 face-override with the following meaning:
23425 DRAW_NORMAL_TEXT draw normally
23426 DRAW_CURSOR draw in cursor face
23427 DRAW_MOUSE_FACE draw in mouse face.
23428 DRAW_INVERSE_VIDEO draw in mode line face
23429 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
23430 DRAW_IMAGE_RAISED draw an image with a raised relief around it
23432 If OVERLAPS is non-zero, draw only the foreground of characters and
23433 clip to the physical height of ROW. Non-zero value also defines
23434 the overlapping part to be drawn:
23436 OVERLAPS_PRED overlap with preceding rows
23437 OVERLAPS_SUCC overlap with succeeding rows
23438 OVERLAPS_BOTH overlap with both preceding/succeeding rows
23439 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
23441 Value is the x-position reached, relative to AREA of W. */
23444 draw_glyphs (struct window
*w
, int x
, struct glyph_row
*row
,
23445 enum glyph_row_area area
, ptrdiff_t start
, ptrdiff_t end
,
23446 enum draw_glyphs_face hl
, int overlaps
)
23448 struct glyph_string
*head
, *tail
;
23449 struct glyph_string
*s
;
23450 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
23451 int i
, j
, x_reached
, last_x
, area_left
= 0;
23452 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
23455 ALLOCATE_HDC (hdc
, f
);
23457 /* Let's rather be paranoid than getting a SEGV. */
23458 end
= min (end
, row
->used
[area
]);
23459 start
= max (0, start
);
23460 start
= min (end
, start
);
23462 /* Translate X to frame coordinates. Set last_x to the right
23463 end of the drawing area. */
23464 if (row
->full_width_p
)
23466 /* X is relative to the left edge of W, without scroll bars
23468 area_left
= WINDOW_LEFT_EDGE_X (w
);
23469 last_x
= WINDOW_LEFT_EDGE_X (w
) + WINDOW_TOTAL_WIDTH (w
);
23473 area_left
= window_box_left (w
, area
);
23474 last_x
= area_left
+ window_box_width (w
, area
);
23478 /* Build a doubly-linked list of glyph_string structures between
23479 head and tail from what we have to draw. Note that the macro
23480 BUILD_GLYPH_STRINGS will modify its start parameter. That's
23481 the reason we use a separate variable `i'. */
23483 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
23485 x_reached
= tail
->x
+ tail
->background_width
;
23489 /* If there are any glyphs with lbearing < 0 or rbearing > width in
23490 the row, redraw some glyphs in front or following the glyph
23491 strings built above. */
23492 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
23494 struct glyph_string
*h
, *t
;
23495 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
23496 int mouse_beg_col
IF_LINT (= 0), mouse_end_col
IF_LINT (= 0);
23497 int check_mouse_face
= 0;
23500 /* If mouse highlighting is on, we may need to draw adjacent
23501 glyphs using mouse-face highlighting. */
23502 if (area
== TEXT_AREA
&& row
->mouse_face_p
)
23504 struct glyph_row
*mouse_beg_row
, *mouse_end_row
;
23506 mouse_beg_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
23507 mouse_end_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
23509 if (row
>= mouse_beg_row
&& row
<= mouse_end_row
)
23511 check_mouse_face
= 1;
23512 mouse_beg_col
= (row
== mouse_beg_row
)
23513 ? hlinfo
->mouse_face_beg_col
: 0;
23514 mouse_end_col
= (row
== mouse_end_row
)
23515 ? hlinfo
->mouse_face_end_col
23516 : row
->used
[TEXT_AREA
];
23520 /* Compute overhangs for all glyph strings. */
23521 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
23522 for (s
= head
; s
; s
= s
->next
)
23523 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
23525 /* Prepend glyph strings for glyphs in front of the first glyph
23526 string that are overwritten because of the first glyph
23527 string's left overhang. The background of all strings
23528 prepended must be drawn because the first glyph string
23530 i
= left_overwritten (head
);
23533 enum draw_glyphs_face overlap_hl
;
23535 /* If this row contains mouse highlighting, attempt to draw
23536 the overlapped glyphs with the correct highlight. This
23537 code fails if the overlap encompasses more than one glyph
23538 and mouse-highlight spans only some of these glyphs.
23539 However, making it work perfectly involves a lot more
23540 code, and I don't know if the pathological case occurs in
23541 practice, so we'll stick to this for now. --- cyd */
23542 if (check_mouse_face
23543 && mouse_beg_col
< start
&& mouse_end_col
> i
)
23544 overlap_hl
= DRAW_MOUSE_FACE
;
23546 overlap_hl
= DRAW_NORMAL_TEXT
;
23549 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
23550 overlap_hl
, dummy_x
, last_x
);
23552 compute_overhangs_and_x (t
, head
->x
, 1);
23553 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
23557 /* Prepend glyph strings for glyphs in front of the first glyph
23558 string that overwrite that glyph string because of their
23559 right overhang. For these strings, only the foreground must
23560 be drawn, because it draws over the glyph string at `head'.
23561 The background must not be drawn because this would overwrite
23562 right overhangs of preceding glyphs for which no glyph
23564 i
= left_overwriting (head
);
23567 enum draw_glyphs_face overlap_hl
;
23569 if (check_mouse_face
23570 && mouse_beg_col
< start
&& mouse_end_col
> i
)
23571 overlap_hl
= DRAW_MOUSE_FACE
;
23573 overlap_hl
= DRAW_NORMAL_TEXT
;
23576 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
23577 overlap_hl
, dummy_x
, last_x
);
23578 for (s
= h
; s
; s
= s
->next
)
23579 s
->background_filled_p
= 1;
23580 compute_overhangs_and_x (t
, head
->x
, 1);
23581 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
23584 /* Append glyphs strings for glyphs following the last glyph
23585 string tail that are overwritten by tail. The background of
23586 these strings has to be drawn because tail's foreground draws
23588 i
= right_overwritten (tail
);
23591 enum draw_glyphs_face overlap_hl
;
23593 if (check_mouse_face
23594 && mouse_beg_col
< i
&& mouse_end_col
> end
)
23595 overlap_hl
= DRAW_MOUSE_FACE
;
23597 overlap_hl
= DRAW_NORMAL_TEXT
;
23599 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
23600 overlap_hl
, x
, last_x
);
23601 /* Because BUILD_GLYPH_STRINGS updates the first argument,
23602 we don't have `end = i;' here. */
23603 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
23604 append_glyph_string_lists (&head
, &tail
, h
, t
);
23608 /* Append glyph strings for glyphs following the last glyph
23609 string tail that overwrite tail. The foreground of such
23610 glyphs has to be drawn because it writes into the background
23611 of tail. The background must not be drawn because it could
23612 paint over the foreground of following glyphs. */
23613 i
= right_overwriting (tail
);
23616 enum draw_glyphs_face overlap_hl
;
23617 if (check_mouse_face
23618 && mouse_beg_col
< i
&& mouse_end_col
> end
)
23619 overlap_hl
= DRAW_MOUSE_FACE
;
23621 overlap_hl
= DRAW_NORMAL_TEXT
;
23624 i
++; /* We must include the Ith glyph. */
23625 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
23626 overlap_hl
, x
, last_x
);
23627 for (s
= h
; s
; s
= s
->next
)
23628 s
->background_filled_p
= 1;
23629 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
23630 append_glyph_string_lists (&head
, &tail
, h
, t
);
23632 if (clip_head
|| clip_tail
)
23633 for (s
= head
; s
; s
= s
->next
)
23635 s
->clip_head
= clip_head
;
23636 s
->clip_tail
= clip_tail
;
23640 /* Draw all strings. */
23641 for (s
= head
; s
; s
= s
->next
)
23642 FRAME_RIF (f
)->draw_glyph_string (s
);
23645 /* When focus a sole frame and move horizontally, this sets on_p to 0
23646 causing a failure to erase prev cursor position. */
23647 if (area
== TEXT_AREA
23648 && !row
->full_width_p
23649 /* When drawing overlapping rows, only the glyph strings'
23650 foreground is drawn, which doesn't erase a cursor
23654 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
23655 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
23656 : (tail
? tail
->x
+ tail
->background_width
: x
));
23660 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
23661 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
23665 /* Value is the x-position up to which drawn, relative to AREA of W.
23666 This doesn't include parts drawn because of overhangs. */
23667 if (row
->full_width_p
)
23668 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
23670 x_reached
-= area_left
;
23672 RELEASE_HDC (hdc
, f
);
23677 /* Expand row matrix if too narrow. Don't expand if area
23680 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
23682 if (!fonts_changed_p \
23683 && (it->glyph_row->glyphs[area] \
23684 < it->glyph_row->glyphs[area + 1])) \
23686 it->w->ncols_scale_factor++; \
23687 fonts_changed_p = 1; \
23691 /* Store one glyph for IT->char_to_display in IT->glyph_row.
23692 Called from x_produce_glyphs when IT->glyph_row is non-null. */
23695 append_glyph (struct it
*it
)
23697 struct glyph
*glyph
;
23698 enum glyph_row_area area
= it
->area
;
23700 eassert (it
->glyph_row
);
23701 eassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
23703 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23704 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23706 /* If the glyph row is reversed, we need to prepend the glyph
23707 rather than append it. */
23708 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
23712 /* Make room for the additional glyph. */
23713 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
23715 glyph
= it
->glyph_row
->glyphs
[area
];
23717 glyph
->charpos
= CHARPOS (it
->position
);
23718 glyph
->object
= it
->object
;
23719 if (it
->pixel_width
> 0)
23721 glyph
->pixel_width
= it
->pixel_width
;
23722 glyph
->padding_p
= 0;
23726 /* Assure at least 1-pixel width. Otherwise, cursor can't
23727 be displayed correctly. */
23728 glyph
->pixel_width
= 1;
23729 glyph
->padding_p
= 1;
23731 glyph
->ascent
= it
->ascent
;
23732 glyph
->descent
= it
->descent
;
23733 glyph
->voffset
= it
->voffset
;
23734 glyph
->type
= CHAR_GLYPH
;
23735 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23736 glyph
->multibyte_p
= it
->multibyte_p
;
23737 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23738 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23739 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
23740 || it
->phys_descent
> it
->descent
);
23741 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
23742 glyph
->face_id
= it
->face_id
;
23743 glyph
->u
.ch
= it
->char_to_display
;
23744 glyph
->slice
.img
= null_glyph_slice
;
23745 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
23748 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
23749 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
23751 glyph
->bidi_type
= it
->bidi_it
.type
;
23755 glyph
->resolved_level
= 0;
23756 glyph
->bidi_type
= UNKNOWN_BT
;
23758 ++it
->glyph_row
->used
[area
];
23761 IT_EXPAND_MATRIX_WIDTH (it
, area
);
23764 /* Store one glyph for the composition IT->cmp_it.id in
23765 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
23769 append_composite_glyph (struct it
*it
)
23771 struct glyph
*glyph
;
23772 enum glyph_row_area area
= it
->area
;
23774 eassert (it
->glyph_row
);
23776 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23777 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23779 /* If the glyph row is reversed, we need to prepend the glyph
23780 rather than append it. */
23781 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
23785 /* Make room for the new glyph. */
23786 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
23788 glyph
= it
->glyph_row
->glyphs
[it
->area
];
23790 glyph
->charpos
= it
->cmp_it
.charpos
;
23791 glyph
->object
= it
->object
;
23792 glyph
->pixel_width
= it
->pixel_width
;
23793 glyph
->ascent
= it
->ascent
;
23794 glyph
->descent
= it
->descent
;
23795 glyph
->voffset
= it
->voffset
;
23796 glyph
->type
= COMPOSITE_GLYPH
;
23797 if (it
->cmp_it
.ch
< 0)
23799 glyph
->u
.cmp
.automatic
= 0;
23800 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
23801 glyph
->slice
.cmp
.from
= glyph
->slice
.cmp
.to
= 0;
23805 glyph
->u
.cmp
.automatic
= 1;
23806 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
23807 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
23808 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
23810 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23811 glyph
->multibyte_p
= it
->multibyte_p
;
23812 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23813 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23814 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
23815 || it
->phys_descent
> it
->descent
);
23816 glyph
->padding_p
= 0;
23817 glyph
->glyph_not_available_p
= 0;
23818 glyph
->face_id
= it
->face_id
;
23819 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
23822 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
23823 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
23825 glyph
->bidi_type
= it
->bidi_it
.type
;
23827 ++it
->glyph_row
->used
[area
];
23830 IT_EXPAND_MATRIX_WIDTH (it
, area
);
23834 /* Change IT->ascent and IT->height according to the setting of
23838 take_vertical_position_into_account (struct it
*it
)
23842 if (it
->voffset
< 0)
23843 /* Increase the ascent so that we can display the text higher
23845 it
->ascent
-= it
->voffset
;
23847 /* Increase the descent so that we can display the text lower
23849 it
->descent
+= it
->voffset
;
23854 /* Produce glyphs/get display metrics for the image IT is loaded with.
23855 See the description of struct display_iterator in dispextern.h for
23856 an overview of struct display_iterator. */
23859 produce_image_glyph (struct it
*it
)
23863 int glyph_ascent
, crop
;
23864 struct glyph_slice slice
;
23866 eassert (it
->what
== IT_IMAGE
);
23868 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23870 /* Make sure X resources of the face is loaded. */
23871 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
23873 if (it
->image_id
< 0)
23875 /* Fringe bitmap. */
23876 it
->ascent
= it
->phys_ascent
= 0;
23877 it
->descent
= it
->phys_descent
= 0;
23878 it
->pixel_width
= 0;
23883 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
23885 /* Make sure X resources of the image is loaded. */
23886 prepare_image_for_display (it
->f
, img
);
23888 slice
.x
= slice
.y
= 0;
23889 slice
.width
= img
->width
;
23890 slice
.height
= img
->height
;
23892 if (INTEGERP (it
->slice
.x
))
23893 slice
.x
= XINT (it
->slice
.x
);
23894 else if (FLOATP (it
->slice
.x
))
23895 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
23897 if (INTEGERP (it
->slice
.y
))
23898 slice
.y
= XINT (it
->slice
.y
);
23899 else if (FLOATP (it
->slice
.y
))
23900 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
23902 if (INTEGERP (it
->slice
.width
))
23903 slice
.width
= XINT (it
->slice
.width
);
23904 else if (FLOATP (it
->slice
.width
))
23905 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
23907 if (INTEGERP (it
->slice
.height
))
23908 slice
.height
= XINT (it
->slice
.height
);
23909 else if (FLOATP (it
->slice
.height
))
23910 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
23912 if (slice
.x
>= img
->width
)
23913 slice
.x
= img
->width
;
23914 if (slice
.y
>= img
->height
)
23915 slice
.y
= img
->height
;
23916 if (slice
.x
+ slice
.width
>= img
->width
)
23917 slice
.width
= img
->width
- slice
.x
;
23918 if (slice
.y
+ slice
.height
> img
->height
)
23919 slice
.height
= img
->height
- slice
.y
;
23921 if (slice
.width
== 0 || slice
.height
== 0)
23924 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
23926 it
->descent
= slice
.height
- glyph_ascent
;
23928 it
->descent
+= img
->vmargin
;
23929 if (slice
.y
+ slice
.height
== img
->height
)
23930 it
->descent
+= img
->vmargin
;
23931 it
->phys_descent
= it
->descent
;
23933 it
->pixel_width
= slice
.width
;
23935 it
->pixel_width
+= img
->hmargin
;
23936 if (slice
.x
+ slice
.width
== img
->width
)
23937 it
->pixel_width
+= img
->hmargin
;
23939 /* It's quite possible for images to have an ascent greater than
23940 their height, so don't get confused in that case. */
23941 if (it
->descent
< 0)
23946 if (face
->box
!= FACE_NO_BOX
)
23948 if (face
->box_line_width
> 0)
23951 it
->ascent
+= face
->box_line_width
;
23952 if (slice
.y
+ slice
.height
== img
->height
)
23953 it
->descent
+= face
->box_line_width
;
23956 if (it
->start_of_box_run_p
&& slice
.x
== 0)
23957 it
->pixel_width
+= eabs (face
->box_line_width
);
23958 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
23959 it
->pixel_width
+= eabs (face
->box_line_width
);
23962 take_vertical_position_into_account (it
);
23964 /* Automatically crop wide image glyphs at right edge so we can
23965 draw the cursor on same display row. */
23966 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
23967 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
23969 it
->pixel_width
-= crop
;
23970 slice
.width
-= crop
;
23975 struct glyph
*glyph
;
23976 enum glyph_row_area area
= it
->area
;
23978 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23979 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23981 glyph
->charpos
= CHARPOS (it
->position
);
23982 glyph
->object
= it
->object
;
23983 glyph
->pixel_width
= it
->pixel_width
;
23984 glyph
->ascent
= glyph_ascent
;
23985 glyph
->descent
= it
->descent
;
23986 glyph
->voffset
= it
->voffset
;
23987 glyph
->type
= IMAGE_GLYPH
;
23988 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23989 glyph
->multibyte_p
= it
->multibyte_p
;
23990 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23991 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23992 glyph
->overlaps_vertically_p
= 0;
23993 glyph
->padding_p
= 0;
23994 glyph
->glyph_not_available_p
= 0;
23995 glyph
->face_id
= it
->face_id
;
23996 glyph
->u
.img_id
= img
->id
;
23997 glyph
->slice
.img
= slice
;
23998 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24001 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24002 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24004 glyph
->bidi_type
= it
->bidi_it
.type
;
24006 ++it
->glyph_row
->used
[area
];
24009 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24014 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
24015 of the glyph, WIDTH and HEIGHT are the width and height of the
24016 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
24019 append_stretch_glyph (struct it
*it
, Lisp_Object object
,
24020 int width
, int height
, int ascent
)
24022 struct glyph
*glyph
;
24023 enum glyph_row_area area
= it
->area
;
24025 eassert (ascent
>= 0 && ascent
<= height
);
24027 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24028 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24030 /* If the glyph row is reversed, we need to prepend the glyph
24031 rather than append it. */
24032 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24036 /* Make room for the additional glyph. */
24037 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
24039 glyph
= it
->glyph_row
->glyphs
[area
];
24041 glyph
->charpos
= CHARPOS (it
->position
);
24042 glyph
->object
= object
;
24043 glyph
->pixel_width
= width
;
24044 glyph
->ascent
= ascent
;
24045 glyph
->descent
= height
- ascent
;
24046 glyph
->voffset
= it
->voffset
;
24047 glyph
->type
= STRETCH_GLYPH
;
24048 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24049 glyph
->multibyte_p
= it
->multibyte_p
;
24050 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24051 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24052 glyph
->overlaps_vertically_p
= 0;
24053 glyph
->padding_p
= 0;
24054 glyph
->glyph_not_available_p
= 0;
24055 glyph
->face_id
= it
->face_id
;
24056 glyph
->u
.stretch
.ascent
= ascent
;
24057 glyph
->u
.stretch
.height
= height
;
24058 glyph
->slice
.img
= null_glyph_slice
;
24059 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24062 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24063 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24065 glyph
->bidi_type
= it
->bidi_it
.type
;
24069 glyph
->resolved_level
= 0;
24070 glyph
->bidi_type
= UNKNOWN_BT
;
24072 ++it
->glyph_row
->used
[area
];
24075 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24078 #endif /* HAVE_WINDOW_SYSTEM */
24080 /* Produce a stretch glyph for iterator IT. IT->object is the value
24081 of the glyph property displayed. The value must be a list
24082 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
24085 1. `:width WIDTH' specifies that the space should be WIDTH *
24086 canonical char width wide. WIDTH may be an integer or floating
24089 2. `:relative-width FACTOR' specifies that the width of the stretch
24090 should be computed from the width of the first character having the
24091 `glyph' property, and should be FACTOR times that width.
24093 3. `:align-to HPOS' specifies that the space should be wide enough
24094 to reach HPOS, a value in canonical character units.
24096 Exactly one of the above pairs must be present.
24098 4. `:height HEIGHT' specifies that the height of the stretch produced
24099 should be HEIGHT, measured in canonical character units.
24101 5. `:relative-height FACTOR' specifies that the height of the
24102 stretch should be FACTOR times the height of the characters having
24103 the glyph property.
24105 Either none or exactly one of 4 or 5 must be present.
24107 6. `:ascent ASCENT' specifies that ASCENT percent of the height
24108 of the stretch should be used for the ascent of the stretch.
24109 ASCENT must be in the range 0 <= ASCENT <= 100. */
24112 produce_stretch_glyph (struct it
*it
)
24114 /* (space :width WIDTH :height HEIGHT ...) */
24115 Lisp_Object prop
, plist
;
24116 int width
= 0, height
= 0, align_to
= -1;
24117 int zero_width_ok_p
= 0;
24119 struct font
*font
= NULL
;
24121 #ifdef HAVE_WINDOW_SYSTEM
24123 int zero_height_ok_p
= 0;
24125 if (FRAME_WINDOW_P (it
->f
))
24127 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24128 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24129 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
24133 /* List should start with `space'. */
24134 eassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
24135 plist
= XCDR (it
->object
);
24137 /* Compute the width of the stretch. */
24138 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
24139 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
24141 /* Absolute width `:width WIDTH' specified and valid. */
24142 zero_width_ok_p
= 1;
24145 #ifdef HAVE_WINDOW_SYSTEM
24146 else if (FRAME_WINDOW_P (it
->f
)
24147 && (prop
= Fplist_get (plist
, QCrelative_width
), NUMVAL (prop
) > 0))
24149 /* Relative width `:relative-width FACTOR' specified and valid.
24150 Compute the width of the characters having the `glyph'
24153 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
24156 if (it
->multibyte_p
)
24157 it2
.c
= it2
.char_to_display
= STRING_CHAR_AND_LENGTH (p
, it2
.len
);
24160 it2
.c
= it2
.char_to_display
= *p
, it2
.len
= 1;
24161 if (! ASCII_CHAR_P (it2
.c
))
24162 it2
.char_to_display
= BYTE8_TO_CHAR (it2
.c
);
24165 it2
.glyph_row
= NULL
;
24166 it2
.what
= IT_CHARACTER
;
24167 x_produce_glyphs (&it2
);
24168 width
= NUMVAL (prop
) * it2
.pixel_width
;
24170 #endif /* HAVE_WINDOW_SYSTEM */
24171 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
24172 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
24174 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
24175 align_to
= (align_to
< 0
24177 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
24178 else if (align_to
< 0)
24179 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
24180 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
24181 zero_width_ok_p
= 1;
24184 /* Nothing specified -> width defaults to canonical char width. */
24185 width
= FRAME_COLUMN_WIDTH (it
->f
);
24187 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
24190 #ifdef HAVE_WINDOW_SYSTEM
24191 /* Compute height. */
24192 if (FRAME_WINDOW_P (it
->f
))
24194 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
24195 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
24198 zero_height_ok_p
= 1;
24200 else if (prop
= Fplist_get (plist
, QCrelative_height
),
24202 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
24204 height
= FONT_HEIGHT (font
);
24206 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
24209 /* Compute percentage of height used for ascent. If
24210 `:ascent ASCENT' is present and valid, use that. Otherwise,
24211 derive the ascent from the font in use. */
24212 if (prop
= Fplist_get (plist
, QCascent
),
24213 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
24214 ascent
= height
* NUMVAL (prop
) / 100.0;
24215 else if (!NILP (prop
)
24216 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
24217 ascent
= min (max (0, (int)tem
), height
);
24219 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
24222 #endif /* HAVE_WINDOW_SYSTEM */
24225 if (width
> 0 && it
->line_wrap
!= TRUNCATE
24226 && it
->current_x
+ width
> it
->last_visible_x
)
24228 width
= it
->last_visible_x
- it
->current_x
;
24229 #ifdef HAVE_WINDOW_SYSTEM
24230 /* Subtract one more pixel from the stretch width, but only on
24231 GUI frames, since on a TTY each glyph is one "pixel" wide. */
24232 width
-= FRAME_WINDOW_P (it
->f
);
24236 if (width
> 0 && height
> 0 && it
->glyph_row
)
24238 Lisp_Object o_object
= it
->object
;
24239 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
24242 if (!STRINGP (object
))
24243 object
= it
->w
->buffer
;
24244 #ifdef HAVE_WINDOW_SYSTEM
24245 if (FRAME_WINDOW_P (it
->f
))
24246 append_stretch_glyph (it
, object
, width
, height
, ascent
);
24250 it
->object
= object
;
24251 it
->char_to_display
= ' ';
24252 it
->pixel_width
= it
->len
= 1;
24254 tty_append_glyph (it
);
24255 it
->object
= o_object
;
24259 it
->pixel_width
= width
;
24260 #ifdef HAVE_WINDOW_SYSTEM
24261 if (FRAME_WINDOW_P (it
->f
))
24263 it
->ascent
= it
->phys_ascent
= ascent
;
24264 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
24265 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
24266 take_vertical_position_into_account (it
);
24270 it
->nglyphs
= width
;
24273 /* Get information about special display element WHAT in an
24274 environment described by IT. WHAT is one of IT_TRUNCATION or
24275 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
24276 non-null glyph_row member. This function ensures that fields like
24277 face_id, c, len of IT are left untouched. */
24280 produce_special_glyphs (struct it
*it
, enum display_element_type what
)
24287 temp_it
.object
= make_number (0);
24288 memset (&temp_it
.current
, 0, sizeof temp_it
.current
);
24290 if (what
== IT_CONTINUATION
)
24292 /* Continuation glyph. For R2L lines, we mirror it by hand. */
24293 if (it
->bidi_it
.paragraph_dir
== R2L
)
24294 SET_GLYPH_FROM_CHAR (glyph
, '/');
24296 SET_GLYPH_FROM_CHAR (glyph
, '\\');
24298 && (gc
= DISP_CONTINUE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
24300 /* FIXME: Should we mirror GC for R2L lines? */
24301 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
24302 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
24305 else if (what
== IT_TRUNCATION
)
24307 /* Truncation glyph. */
24308 SET_GLYPH_FROM_CHAR (glyph
, '$');
24310 && (gc
= DISP_TRUNC_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
24312 /* FIXME: Should we mirror GC for R2L lines? */
24313 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
24314 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
24320 #ifdef HAVE_WINDOW_SYSTEM
24321 /* On a GUI frame, when the right fringe (left fringe for R2L rows)
24322 is turned off, we precede the truncation/continuation glyphs by a
24323 stretch glyph whose width is computed such that these special
24324 glyphs are aligned at the window margin, even when very different
24325 fonts are used in different glyph rows. */
24326 if (FRAME_WINDOW_P (temp_it
.f
)
24327 /* init_iterator calls this with it->glyph_row == NULL, and it
24328 wants only the pixel width of the truncation/continuation
24330 && temp_it
.glyph_row
24331 /* insert_left_trunc_glyphs calls us at the beginning of the
24332 row, and it has its own calculation of the stretch glyph
24334 && temp_it
.glyph_row
->used
[TEXT_AREA
] > 0
24335 && (temp_it
.glyph_row
->reversed_p
24336 ? WINDOW_LEFT_FRINGE_WIDTH (temp_it
.w
)
24337 : WINDOW_RIGHT_FRINGE_WIDTH (temp_it
.w
)) == 0)
24339 int stretch_width
= temp_it
.last_visible_x
- temp_it
.current_x
;
24341 if (stretch_width
> 0)
24343 struct face
*face
= FACE_FROM_ID (temp_it
.f
, temp_it
.face_id
);
24344 struct font
*font
=
24345 face
->font
? face
->font
: FRAME_FONT (temp_it
.f
);
24346 int stretch_ascent
=
24347 (((temp_it
.ascent
+ temp_it
.descent
)
24348 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
24350 append_stretch_glyph (&temp_it
, make_number (0), stretch_width
,
24351 temp_it
.ascent
+ temp_it
.descent
,
24358 temp_it
.what
= IT_CHARACTER
;
24360 temp_it
.c
= temp_it
.char_to_display
= GLYPH_CHAR (glyph
);
24361 temp_it
.face_id
= GLYPH_FACE (glyph
);
24362 temp_it
.len
= CHAR_BYTES (temp_it
.c
);
24364 PRODUCE_GLYPHS (&temp_it
);
24365 it
->pixel_width
= temp_it
.pixel_width
;
24366 it
->nglyphs
= temp_it
.pixel_width
;
24369 #ifdef HAVE_WINDOW_SYSTEM
24371 /* Calculate line-height and line-spacing properties.
24372 An integer value specifies explicit pixel value.
24373 A float value specifies relative value to current face height.
24374 A cons (float . face-name) specifies relative value to
24375 height of specified face font.
24377 Returns height in pixels, or nil. */
24381 calc_line_height_property (struct it
*it
, Lisp_Object val
, struct font
*font
,
24382 int boff
, int override
)
24384 Lisp_Object face_name
= Qnil
;
24385 int ascent
, descent
, height
;
24387 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
24392 face_name
= XCAR (val
);
24394 if (!NUMBERP (val
))
24395 val
= make_number (1);
24396 if (NILP (face_name
))
24398 height
= it
->ascent
+ it
->descent
;
24403 if (NILP (face_name
))
24405 font
= FRAME_FONT (it
->f
);
24406 boff
= FRAME_BASELINE_OFFSET (it
->f
);
24408 else if (EQ (face_name
, Qt
))
24417 face_id
= lookup_named_face (it
->f
, face_name
, 0);
24419 return make_number (-1);
24421 face
= FACE_FROM_ID (it
->f
, face_id
);
24424 return make_number (-1);
24425 boff
= font
->baseline_offset
;
24426 if (font
->vertical_centering
)
24427 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
24430 ascent
= FONT_BASE (font
) + boff
;
24431 descent
= FONT_DESCENT (font
) - boff
;
24435 it
->override_ascent
= ascent
;
24436 it
->override_descent
= descent
;
24437 it
->override_boff
= boff
;
24440 height
= ascent
+ descent
;
24444 height
= (int)(XFLOAT_DATA (val
) * height
);
24445 else if (INTEGERP (val
))
24446 height
*= XINT (val
);
24448 return make_number (height
);
24452 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
24453 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
24454 and only if this is for a character for which no font was found.
24456 If the display method (it->glyphless_method) is
24457 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
24458 length of the acronym or the hexadecimal string, UPPER_XOFF and
24459 UPPER_YOFF are pixel offsets for the upper part of the string,
24460 LOWER_XOFF and LOWER_YOFF are for the lower part.
24462 For the other display methods, LEN through LOWER_YOFF are zero. */
24465 append_glyphless_glyph (struct it
*it
, int face_id
, int for_no_font
, int len
,
24466 short upper_xoff
, short upper_yoff
,
24467 short lower_xoff
, short lower_yoff
)
24469 struct glyph
*glyph
;
24470 enum glyph_row_area area
= it
->area
;
24472 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24473 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24475 /* If the glyph row is reversed, we need to prepend the glyph
24476 rather than append it. */
24477 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24481 /* Make room for the additional glyph. */
24482 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
24484 glyph
= it
->glyph_row
->glyphs
[area
];
24486 glyph
->charpos
= CHARPOS (it
->position
);
24487 glyph
->object
= it
->object
;
24488 glyph
->pixel_width
= it
->pixel_width
;
24489 glyph
->ascent
= it
->ascent
;
24490 glyph
->descent
= it
->descent
;
24491 glyph
->voffset
= it
->voffset
;
24492 glyph
->type
= GLYPHLESS_GLYPH
;
24493 glyph
->u
.glyphless
.method
= it
->glyphless_method
;
24494 glyph
->u
.glyphless
.for_no_font
= for_no_font
;
24495 glyph
->u
.glyphless
.len
= len
;
24496 glyph
->u
.glyphless
.ch
= it
->c
;
24497 glyph
->slice
.glyphless
.upper_xoff
= upper_xoff
;
24498 glyph
->slice
.glyphless
.upper_yoff
= upper_yoff
;
24499 glyph
->slice
.glyphless
.lower_xoff
= lower_xoff
;
24500 glyph
->slice
.glyphless
.lower_yoff
= lower_yoff
;
24501 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24502 glyph
->multibyte_p
= it
->multibyte_p
;
24503 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24504 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24505 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
24506 || it
->phys_descent
> it
->descent
);
24507 glyph
->padding_p
= 0;
24508 glyph
->glyph_not_available_p
= 0;
24509 glyph
->face_id
= face_id
;
24510 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24513 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24514 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24516 glyph
->bidi_type
= it
->bidi_it
.type
;
24518 ++it
->glyph_row
->used
[area
];
24521 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24525 /* Produce a glyph for a glyphless character for iterator IT.
24526 IT->glyphless_method specifies which method to use for displaying
24527 the character. See the description of enum
24528 glyphless_display_method in dispextern.h for the detail.
24530 FOR_NO_FONT is nonzero if and only if this is for a character for
24531 which no font was found. ACRONYM, if non-nil, is an acronym string
24532 for the character. */
24535 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
24540 int base_width
, base_height
, width
, height
;
24541 short upper_xoff
, upper_yoff
, lower_xoff
, lower_yoff
;
24544 /* Get the metrics of the base font. We always refer to the current
24546 face
= FACE_FROM_ID (it
->f
, it
->face_id
)->ascii_face
;
24547 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24548 it
->ascent
= FONT_BASE (font
) + font
->baseline_offset
;
24549 it
->descent
= FONT_DESCENT (font
) - font
->baseline_offset
;
24550 base_height
= it
->ascent
+ it
->descent
;
24551 base_width
= font
->average_width
;
24553 /* Get a face ID for the glyph by utilizing a cache (the same way as
24554 done for `escape-glyph' in get_next_display_element). */
24555 if (it
->f
== last_glyphless_glyph_frame
24556 && it
->face_id
== last_glyphless_glyph_face_id
)
24558 face_id
= last_glyphless_glyph_merged_face_id
;
24562 /* Merge the `glyphless-char' face into the current face. */
24563 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
24564 last_glyphless_glyph_frame
= it
->f
;
24565 last_glyphless_glyph_face_id
= it
->face_id
;
24566 last_glyphless_glyph_merged_face_id
= face_id
;
24569 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
24571 it
->pixel_width
= THIN_SPACE_WIDTH
;
24573 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
24575 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
24577 width
= CHAR_WIDTH (it
->c
);
24580 else if (width
> 4)
24582 it
->pixel_width
= base_width
* width
;
24584 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
24590 unsigned int code
[6];
24592 int ascent
, descent
;
24593 struct font_metrics metrics_upper
, metrics_lower
;
24595 face
= FACE_FROM_ID (it
->f
, face_id
);
24596 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24597 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
24599 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
24601 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
24602 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
24603 if (CONSP (acronym
))
24604 acronym
= XCAR (acronym
);
24605 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
24609 eassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
24610 sprintf (buf
, "%0*X", it
->c
< 0x10000 ? 4 : 6, it
->c
);
24613 for (len
= 0; str
[len
] && ASCII_BYTE_P (str
[len
]) && len
< 6; len
++)
24614 code
[len
] = font
->driver
->encode_char (font
, str
[len
]);
24615 upper_len
= (len
+ 1) / 2;
24616 font
->driver
->text_extents (font
, code
, upper_len
,
24618 font
->driver
->text_extents (font
, code
+ upper_len
, len
- upper_len
,
24623 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
24624 width
= max (metrics_upper
.width
, metrics_lower
.width
) + 4;
24625 upper_xoff
= upper_yoff
= 2; /* the typical case */
24626 if (base_width
>= width
)
24628 /* Align the upper to the left, the lower to the right. */
24629 it
->pixel_width
= base_width
;
24630 lower_xoff
= base_width
- 2 - metrics_lower
.width
;
24634 /* Center the shorter one. */
24635 it
->pixel_width
= width
;
24636 if (metrics_upper
.width
>= metrics_lower
.width
)
24637 lower_xoff
= (width
- metrics_lower
.width
) / 2;
24640 /* FIXME: This code doesn't look right. It formerly was
24641 missing the "lower_xoff = 0;", which couldn't have
24642 been right since it left lower_xoff uninitialized. */
24644 upper_xoff
= (width
- metrics_upper
.width
) / 2;
24648 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
24649 top, bottom, and between upper and lower strings. */
24650 height
= (metrics_upper
.ascent
+ metrics_upper
.descent
24651 + metrics_lower
.ascent
+ metrics_lower
.descent
) + 5;
24652 /* Center vertically.
24653 H:base_height, D:base_descent
24654 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
24656 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
24657 descent = D - H/2 + h/2;
24658 lower_yoff = descent - 2 - ld;
24659 upper_yoff = lower_yoff - la - 1 - ud; */
24660 ascent
= - (it
->descent
- (base_height
+ height
+ 1) / 2);
24661 descent
= it
->descent
- (base_height
- height
) / 2;
24662 lower_yoff
= descent
- 2 - metrics_lower
.descent
;
24663 upper_yoff
= (lower_yoff
- metrics_lower
.ascent
- 1
24664 - metrics_upper
.descent
);
24665 /* Don't make the height shorter than the base height. */
24666 if (height
> base_height
)
24668 it
->ascent
= ascent
;
24669 it
->descent
= descent
;
24673 it
->phys_ascent
= it
->ascent
;
24674 it
->phys_descent
= it
->descent
;
24676 append_glyphless_glyph (it
, face_id
, for_no_font
, len
,
24677 upper_xoff
, upper_yoff
,
24678 lower_xoff
, lower_yoff
);
24680 take_vertical_position_into_account (it
);
24685 Produce glyphs/get display metrics for the display element IT is
24686 loaded with. See the description of struct it in dispextern.h
24687 for an overview of struct it. */
24690 x_produce_glyphs (struct it
*it
)
24692 int extra_line_spacing
= it
->extra_line_spacing
;
24694 it
->glyph_not_available_p
= 0;
24696 if (it
->what
== IT_CHARACTER
)
24699 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24700 struct font
*font
= face
->font
;
24701 struct font_metrics
*pcm
= NULL
;
24702 int boff
; /* baseline offset */
24706 /* When no suitable font is found, display this character by
24707 the method specified in the first extra slot of
24708 Vglyphless_char_display. */
24709 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
24711 eassert (it
->what
== IT_GLYPHLESS
);
24712 produce_glyphless_glyph (it
, 1, STRINGP (acronym
) ? acronym
: Qnil
);
24716 boff
= font
->baseline_offset
;
24717 if (font
->vertical_centering
)
24718 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
24720 if (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t')
24726 if (it
->override_ascent
>= 0)
24728 it
->ascent
= it
->override_ascent
;
24729 it
->descent
= it
->override_descent
;
24730 boff
= it
->override_boff
;
24734 it
->ascent
= FONT_BASE (font
) + boff
;
24735 it
->descent
= FONT_DESCENT (font
) - boff
;
24738 if (get_char_glyph_code (it
->char_to_display
, font
, &char2b
))
24740 pcm
= get_per_char_metric (font
, &char2b
);
24741 if (pcm
->width
== 0
24742 && pcm
->rbearing
== 0 && pcm
->lbearing
== 0)
24748 it
->phys_ascent
= pcm
->ascent
+ boff
;
24749 it
->phys_descent
= pcm
->descent
- boff
;
24750 it
->pixel_width
= pcm
->width
;
24754 it
->glyph_not_available_p
= 1;
24755 it
->phys_ascent
= it
->ascent
;
24756 it
->phys_descent
= it
->descent
;
24757 it
->pixel_width
= font
->space_width
;
24760 if (it
->constrain_row_ascent_descent_p
)
24762 if (it
->descent
> it
->max_descent
)
24764 it
->ascent
+= it
->descent
- it
->max_descent
;
24765 it
->descent
= it
->max_descent
;
24767 if (it
->ascent
> it
->max_ascent
)
24769 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
24770 it
->ascent
= it
->max_ascent
;
24772 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
24773 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
24774 extra_line_spacing
= 0;
24777 /* If this is a space inside a region of text with
24778 `space-width' property, change its width. */
24779 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
24781 it
->pixel_width
*= XFLOATINT (it
->space_width
);
24783 /* If face has a box, add the box thickness to the character
24784 height. If character has a box line to the left and/or
24785 right, add the box line width to the character's width. */
24786 if (face
->box
!= FACE_NO_BOX
)
24788 int thick
= face
->box_line_width
;
24792 it
->ascent
+= thick
;
24793 it
->descent
+= thick
;
24798 if (it
->start_of_box_run_p
)
24799 it
->pixel_width
+= thick
;
24800 if (it
->end_of_box_run_p
)
24801 it
->pixel_width
+= thick
;
24804 /* If face has an overline, add the height of the overline
24805 (1 pixel) and a 1 pixel margin to the character height. */
24806 if (face
->overline_p
)
24807 it
->ascent
+= overline_margin
;
24809 if (it
->constrain_row_ascent_descent_p
)
24811 if (it
->ascent
> it
->max_ascent
)
24812 it
->ascent
= it
->max_ascent
;
24813 if (it
->descent
> it
->max_descent
)
24814 it
->descent
= it
->max_descent
;
24817 take_vertical_position_into_account (it
);
24819 /* If we have to actually produce glyphs, do it. */
24824 /* Translate a space with a `space-width' property
24825 into a stretch glyph. */
24826 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
24827 / FONT_HEIGHT (font
));
24828 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
24829 it
->ascent
+ it
->descent
, ascent
);
24834 /* If characters with lbearing or rbearing are displayed
24835 in this line, record that fact in a flag of the
24836 glyph row. This is used to optimize X output code. */
24837 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
24838 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
24840 if (! stretched_p
&& it
->pixel_width
== 0)
24841 /* We assure that all visible glyphs have at least 1-pixel
24843 it
->pixel_width
= 1;
24845 else if (it
->char_to_display
== '\n')
24847 /* A newline has no width, but we need the height of the
24848 line. But if previous part of the line sets a height,
24849 don't increase that height */
24851 Lisp_Object height
;
24852 Lisp_Object total_height
= Qnil
;
24854 it
->override_ascent
= -1;
24855 it
->pixel_width
= 0;
24858 height
= get_it_property (it
, Qline_height
);
24859 /* Split (line-height total-height) list */
24861 && CONSP (XCDR (height
))
24862 && NILP (XCDR (XCDR (height
))))
24864 total_height
= XCAR (XCDR (height
));
24865 height
= XCAR (height
);
24867 height
= calc_line_height_property (it
, height
, font
, boff
, 1);
24869 if (it
->override_ascent
>= 0)
24871 it
->ascent
= it
->override_ascent
;
24872 it
->descent
= it
->override_descent
;
24873 boff
= it
->override_boff
;
24877 it
->ascent
= FONT_BASE (font
) + boff
;
24878 it
->descent
= FONT_DESCENT (font
) - boff
;
24881 if (EQ (height
, Qt
))
24883 if (it
->descent
> it
->max_descent
)
24885 it
->ascent
+= it
->descent
- it
->max_descent
;
24886 it
->descent
= it
->max_descent
;
24888 if (it
->ascent
> it
->max_ascent
)
24890 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
24891 it
->ascent
= it
->max_ascent
;
24893 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
24894 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
24895 it
->constrain_row_ascent_descent_p
= 1;
24896 extra_line_spacing
= 0;
24900 Lisp_Object spacing
;
24902 it
->phys_ascent
= it
->ascent
;
24903 it
->phys_descent
= it
->descent
;
24905 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
24906 && face
->box
!= FACE_NO_BOX
24907 && face
->box_line_width
> 0)
24909 it
->ascent
+= face
->box_line_width
;
24910 it
->descent
+= face
->box_line_width
;
24913 && XINT (height
) > it
->ascent
+ it
->descent
)
24914 it
->ascent
= XINT (height
) - it
->descent
;
24916 if (!NILP (total_height
))
24917 spacing
= calc_line_height_property (it
, total_height
, font
, boff
, 0);
24920 spacing
= get_it_property (it
, Qline_spacing
);
24921 spacing
= calc_line_height_property (it
, spacing
, font
, boff
, 0);
24923 if (INTEGERP (spacing
))
24925 extra_line_spacing
= XINT (spacing
);
24926 if (!NILP (total_height
))
24927 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
24931 else /* i.e. (it->char_to_display == '\t') */
24933 if (font
->space_width
> 0)
24935 int tab_width
= it
->tab_width
* font
->space_width
;
24936 int x
= it
->current_x
+ it
->continuation_lines_width
;
24937 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
24939 /* If the distance from the current position to the next tab
24940 stop is less than a space character width, use the
24941 tab stop after that. */
24942 if (next_tab_x
- x
< font
->space_width
)
24943 next_tab_x
+= tab_width
;
24945 it
->pixel_width
= next_tab_x
- x
;
24947 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
24948 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
24952 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
24953 it
->ascent
+ it
->descent
, it
->ascent
);
24958 it
->pixel_width
= 0;
24963 else if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
< 0)
24965 /* A static composition.
24967 Note: A composition is represented as one glyph in the
24968 glyph matrix. There are no padding glyphs.
24970 Important note: pixel_width, ascent, and descent are the
24971 values of what is drawn by draw_glyphs (i.e. the values of
24972 the overall glyphs composed). */
24973 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24974 int boff
; /* baseline offset */
24975 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
24976 int glyph_len
= cmp
->glyph_len
;
24977 struct font
*font
= face
->font
;
24981 /* If we have not yet calculated pixel size data of glyphs of
24982 the composition for the current face font, calculate them
24983 now. Theoretically, we have to check all fonts for the
24984 glyphs, but that requires much time and memory space. So,
24985 here we check only the font of the first glyph. This may
24986 lead to incorrect display, but it's very rare, and C-l
24987 (recenter-top-bottom) can correct the display anyway. */
24988 if (! cmp
->font
|| cmp
->font
!= font
)
24990 /* Ascent and descent of the font of the first character
24991 of this composition (adjusted by baseline offset).
24992 Ascent and descent of overall glyphs should not be less
24993 than these, respectively. */
24994 int font_ascent
, font_descent
, font_height
;
24995 /* Bounding box of the overall glyphs. */
24996 int leftmost
, rightmost
, lowest
, highest
;
24997 int lbearing
, rbearing
;
24998 int i
, width
, ascent
, descent
;
24999 int left_padded
= 0, right_padded
= 0;
25000 int c
IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
25002 struct font_metrics
*pcm
;
25003 int font_not_found_p
;
25006 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
25007 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
25009 if (glyph_len
< cmp
->glyph_len
)
25011 for (i
= 0; i
< glyph_len
; i
++)
25013 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
25015 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
25020 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
25021 : IT_CHARPOS (*it
));
25022 /* If no suitable font is found, use the default font. */
25023 font_not_found_p
= font
== NULL
;
25024 if (font_not_found_p
)
25026 face
= face
->ascii_face
;
25029 boff
= font
->baseline_offset
;
25030 if (font
->vertical_centering
)
25031 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
25032 font_ascent
= FONT_BASE (font
) + boff
;
25033 font_descent
= FONT_DESCENT (font
) - boff
;
25034 font_height
= FONT_HEIGHT (font
);
25039 if (! font_not_found_p
)
25041 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
25043 pcm
= get_per_char_metric (font
, &char2b
);
25046 /* Initialize the bounding box. */
25049 width
= cmp
->glyph_len
> 0 ? pcm
->width
: 0;
25050 ascent
= pcm
->ascent
;
25051 descent
= pcm
->descent
;
25052 lbearing
= pcm
->lbearing
;
25053 rbearing
= pcm
->rbearing
;
25057 width
= cmp
->glyph_len
> 0 ? font
->space_width
: 0;
25058 ascent
= FONT_BASE (font
);
25059 descent
= FONT_DESCENT (font
);
25066 lowest
= - descent
+ boff
;
25067 highest
= ascent
+ boff
;
25069 if (! font_not_found_p
25070 && font
->default_ascent
25071 && CHAR_TABLE_P (Vuse_default_ascent
)
25072 && !NILP (Faref (Vuse_default_ascent
,
25073 make_number (it
->char_to_display
))))
25074 highest
= font
->default_ascent
+ boff
;
25076 /* Draw the first glyph at the normal position. It may be
25077 shifted to right later if some other glyphs are drawn
25079 cmp
->offsets
[i
* 2] = 0;
25080 cmp
->offsets
[i
* 2 + 1] = boff
;
25081 cmp
->lbearing
= lbearing
;
25082 cmp
->rbearing
= rbearing
;
25084 /* Set cmp->offsets for the remaining glyphs. */
25085 for (i
++; i
< glyph_len
; i
++)
25087 int left
, right
, btm
, top
;
25088 int ch
= COMPOSITION_GLYPH (cmp
, i
);
25090 struct face
*this_face
;
25094 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
25095 this_face
= FACE_FROM_ID (it
->f
, face_id
);
25096 font
= this_face
->font
;
25102 get_char_face_and_encoding (it
->f
, ch
, face_id
,
25104 pcm
= get_per_char_metric (font
, &char2b
);
25107 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
25110 width
= pcm
->width
;
25111 ascent
= pcm
->ascent
;
25112 descent
= pcm
->descent
;
25113 lbearing
= pcm
->lbearing
;
25114 rbearing
= pcm
->rbearing
;
25115 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
25117 /* Relative composition with or without
25118 alternate chars. */
25119 left
= (leftmost
+ rightmost
- width
) / 2;
25120 btm
= - descent
+ boff
;
25121 if (font
->relative_compose
25122 && (! CHAR_TABLE_P (Vignore_relative_composition
)
25123 || NILP (Faref (Vignore_relative_composition
,
25124 make_number (ch
)))))
25127 if (- descent
>= font
->relative_compose
)
25128 /* One extra pixel between two glyphs. */
25130 else if (ascent
<= 0)
25131 /* One extra pixel between two glyphs. */
25132 btm
= lowest
- 1 - ascent
- descent
;
25137 /* A composition rule is specified by an integer
25138 value that encodes global and new reference
25139 points (GREF and NREF). GREF and NREF are
25140 specified by numbers as below:
25142 0---1---2 -- ascent
25146 9--10--11 -- center
25148 ---3---4---5--- baseline
25150 6---7---8 -- descent
25152 int rule
= COMPOSITION_RULE (cmp
, i
);
25153 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
25155 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
25156 grefx
= gref
% 3, nrefx
= nref
% 3;
25157 grefy
= gref
/ 3, nrefy
= nref
/ 3;
25159 xoff
= font_height
* (xoff
- 128) / 256;
25161 yoff
= font_height
* (yoff
- 128) / 256;
25164 + grefx
* (rightmost
- leftmost
) / 2
25165 - nrefx
* width
/ 2
25168 btm
= ((grefy
== 0 ? highest
25170 : grefy
== 2 ? lowest
25171 : (highest
+ lowest
) / 2)
25172 - (nrefy
== 0 ? ascent
+ descent
25173 : nrefy
== 1 ? descent
- boff
25175 : (ascent
+ descent
) / 2)
25179 cmp
->offsets
[i
* 2] = left
;
25180 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
25182 /* Update the bounding box of the overall glyphs. */
25185 right
= left
+ width
;
25186 if (left
< leftmost
)
25188 if (right
> rightmost
)
25191 top
= btm
+ descent
+ ascent
;
25197 if (cmp
->lbearing
> left
+ lbearing
)
25198 cmp
->lbearing
= left
+ lbearing
;
25199 if (cmp
->rbearing
< left
+ rbearing
)
25200 cmp
->rbearing
= left
+ rbearing
;
25204 /* If there are glyphs whose x-offsets are negative,
25205 shift all glyphs to the right and make all x-offsets
25209 for (i
= 0; i
< cmp
->glyph_len
; i
++)
25210 cmp
->offsets
[i
* 2] -= leftmost
;
25211 rightmost
-= leftmost
;
25212 cmp
->lbearing
-= leftmost
;
25213 cmp
->rbearing
-= leftmost
;
25216 if (left_padded
&& cmp
->lbearing
< 0)
25218 for (i
= 0; i
< cmp
->glyph_len
; i
++)
25219 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
25220 rightmost
-= cmp
->lbearing
;
25221 cmp
->rbearing
-= cmp
->lbearing
;
25224 if (right_padded
&& rightmost
< cmp
->rbearing
)
25226 rightmost
= cmp
->rbearing
;
25229 cmp
->pixel_width
= rightmost
;
25230 cmp
->ascent
= highest
;
25231 cmp
->descent
= - lowest
;
25232 if (cmp
->ascent
< font_ascent
)
25233 cmp
->ascent
= font_ascent
;
25234 if (cmp
->descent
< font_descent
)
25235 cmp
->descent
= font_descent
;
25239 && (cmp
->lbearing
< 0
25240 || cmp
->rbearing
> cmp
->pixel_width
))
25241 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
25243 it
->pixel_width
= cmp
->pixel_width
;
25244 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
25245 it
->descent
= it
->phys_descent
= cmp
->descent
;
25246 if (face
->box
!= FACE_NO_BOX
)
25248 int thick
= face
->box_line_width
;
25252 it
->ascent
+= thick
;
25253 it
->descent
+= thick
;
25258 if (it
->start_of_box_run_p
)
25259 it
->pixel_width
+= thick
;
25260 if (it
->end_of_box_run_p
)
25261 it
->pixel_width
+= thick
;
25264 /* If face has an overline, add the height of the overline
25265 (1 pixel) and a 1 pixel margin to the character height. */
25266 if (face
->overline_p
)
25267 it
->ascent
+= overline_margin
;
25269 take_vertical_position_into_account (it
);
25270 if (it
->ascent
< 0)
25272 if (it
->descent
< 0)
25275 if (it
->glyph_row
&& cmp
->glyph_len
> 0)
25276 append_composite_glyph (it
);
25278 else if (it
->what
== IT_COMPOSITION
)
25280 /* A dynamic (automatic) composition. */
25281 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
25282 Lisp_Object gstring
;
25283 struct font_metrics metrics
;
25287 gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
25289 = composition_gstring_width (gstring
, it
->cmp_it
.from
, it
->cmp_it
.to
,
25292 && (metrics
.lbearing
< 0 || metrics
.rbearing
> metrics
.width
))
25293 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
25294 it
->ascent
= it
->phys_ascent
= metrics
.ascent
;
25295 it
->descent
= it
->phys_descent
= metrics
.descent
;
25296 if (face
->box
!= FACE_NO_BOX
)
25298 int thick
= face
->box_line_width
;
25302 it
->ascent
+= thick
;
25303 it
->descent
+= thick
;
25308 if (it
->start_of_box_run_p
)
25309 it
->pixel_width
+= thick
;
25310 if (it
->end_of_box_run_p
)
25311 it
->pixel_width
+= thick
;
25313 /* If face has an overline, add the height of the overline
25314 (1 pixel) and a 1 pixel margin to the character height. */
25315 if (face
->overline_p
)
25316 it
->ascent
+= overline_margin
;
25317 take_vertical_position_into_account (it
);
25318 if (it
->ascent
< 0)
25320 if (it
->descent
< 0)
25324 append_composite_glyph (it
);
25326 else if (it
->what
== IT_GLYPHLESS
)
25327 produce_glyphless_glyph (it
, 0, Qnil
);
25328 else if (it
->what
== IT_IMAGE
)
25329 produce_image_glyph (it
);
25330 else if (it
->what
== IT_STRETCH
)
25331 produce_stretch_glyph (it
);
25334 /* Accumulate dimensions. Note: can't assume that it->descent > 0
25335 because this isn't true for images with `:ascent 100'. */
25336 eassert (it
->ascent
>= 0 && it
->descent
>= 0);
25337 if (it
->area
== TEXT_AREA
)
25338 it
->current_x
+= it
->pixel_width
;
25340 if (extra_line_spacing
> 0)
25342 it
->descent
+= extra_line_spacing
;
25343 if (extra_line_spacing
> it
->max_extra_line_spacing
)
25344 it
->max_extra_line_spacing
= extra_line_spacing
;
25347 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
25348 it
->max_descent
= max (it
->max_descent
, it
->descent
);
25349 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
25350 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
25354 Output LEN glyphs starting at START at the nominal cursor position.
25355 Advance the nominal cursor over the text. The global variable
25356 updated_window contains the window being updated, updated_row is
25357 the glyph row being updated, and updated_area is the area of that
25358 row being updated. */
25361 x_write_glyphs (struct glyph
*start
, int len
)
25363 int x
, hpos
, chpos
= updated_window
->phys_cursor
.hpos
;
25365 eassert (updated_window
&& updated_row
);
25366 /* When the window is hscrolled, cursor hpos can legitimately be out
25367 of bounds, but we draw the cursor at the corresponding window
25368 margin in that case. */
25369 if (!updated_row
->reversed_p
&& chpos
< 0)
25371 if (updated_row
->reversed_p
&& chpos
>= updated_row
->used
[TEXT_AREA
])
25372 chpos
= updated_row
->used
[TEXT_AREA
] - 1;
25376 /* Write glyphs. */
25378 hpos
= start
- updated_row
->glyphs
[updated_area
];
25379 x
= draw_glyphs (updated_window
, output_cursor
.x
,
25380 updated_row
, updated_area
,
25382 DRAW_NORMAL_TEXT
, 0);
25384 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
25385 if (updated_area
== TEXT_AREA
25386 && updated_window
->phys_cursor_on_p
25387 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
25389 && chpos
< hpos
+ len
)
25390 updated_window
->phys_cursor_on_p
= 0;
25394 /* Advance the output cursor. */
25395 output_cursor
.hpos
+= len
;
25396 output_cursor
.x
= x
;
25401 Insert LEN glyphs from START at the nominal cursor position. */
25404 x_insert_glyphs (struct glyph
*start
, int len
)
25408 int line_height
, shift_by_width
, shifted_region_width
;
25409 struct glyph_row
*row
;
25410 struct glyph
*glyph
;
25411 int frame_x
, frame_y
;
25414 eassert (updated_window
&& updated_row
);
25416 w
= updated_window
;
25417 f
= XFRAME (WINDOW_FRAME (w
));
25419 /* Get the height of the line we are in. */
25421 line_height
= row
->height
;
25423 /* Get the width of the glyphs to insert. */
25424 shift_by_width
= 0;
25425 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
25426 shift_by_width
+= glyph
->pixel_width
;
25428 /* Get the width of the region to shift right. */
25429 shifted_region_width
= (window_box_width (w
, updated_area
)
25434 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
25435 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
25437 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
25438 line_height
, shift_by_width
);
25440 /* Write the glyphs. */
25441 hpos
= start
- row
->glyphs
[updated_area
];
25442 draw_glyphs (w
, output_cursor
.x
, row
, updated_area
,
25444 DRAW_NORMAL_TEXT
, 0);
25446 /* Advance the output cursor. */
25447 output_cursor
.hpos
+= len
;
25448 output_cursor
.x
+= shift_by_width
;
25454 Erase the current text line from the nominal cursor position
25455 (inclusive) to pixel column TO_X (exclusive). The idea is that
25456 everything from TO_X onward is already erased.
25458 TO_X is a pixel position relative to updated_area of
25459 updated_window. TO_X == -1 means clear to the end of this area. */
25462 x_clear_end_of_line (int to_x
)
25465 struct window
*w
= updated_window
;
25466 int max_x
, min_y
, max_y
;
25467 int from_x
, from_y
, to_y
;
25469 eassert (updated_window
&& updated_row
);
25470 f
= XFRAME (w
->frame
);
25472 if (updated_row
->full_width_p
)
25473 max_x
= WINDOW_TOTAL_WIDTH (w
);
25475 max_x
= window_box_width (w
, updated_area
);
25476 max_y
= window_text_bottom_y (w
);
25478 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
25479 of window. For TO_X > 0, truncate to end of drawing area. */
25485 to_x
= min (to_x
, max_x
);
25487 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
25489 /* Notice if the cursor will be cleared by this operation. */
25490 if (!updated_row
->full_width_p
)
25491 notice_overwritten_cursor (w
, updated_area
,
25492 output_cursor
.x
, -1,
25494 MATRIX_ROW_BOTTOM_Y (updated_row
));
25496 from_x
= output_cursor
.x
;
25498 /* Translate to frame coordinates. */
25499 if (updated_row
->full_width_p
)
25501 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
25502 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
25506 int area_left
= window_box_left (w
, updated_area
);
25507 from_x
+= area_left
;
25511 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
25512 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
25513 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
25515 /* Prevent inadvertently clearing to end of the X window. */
25516 if (to_x
> from_x
&& to_y
> from_y
)
25519 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
25520 to_x
- from_x
, to_y
- from_y
);
25525 #endif /* HAVE_WINDOW_SYSTEM */
25529 /***********************************************************************
25531 ***********************************************************************/
25533 /* Value is the internal representation of the specified cursor type
25534 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
25535 of the bar cursor. */
25537 static enum text_cursor_kinds
25538 get_specified_cursor_type (Lisp_Object arg
, int *width
)
25540 enum text_cursor_kinds type
;
25545 if (EQ (arg
, Qbox
))
25546 return FILLED_BOX_CURSOR
;
25548 if (EQ (arg
, Qhollow
))
25549 return HOLLOW_BOX_CURSOR
;
25551 if (EQ (arg
, Qbar
))
25558 && EQ (XCAR (arg
), Qbar
)
25559 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
25561 *width
= XINT (XCDR (arg
));
25565 if (EQ (arg
, Qhbar
))
25568 return HBAR_CURSOR
;
25572 && EQ (XCAR (arg
), Qhbar
)
25573 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
25575 *width
= XINT (XCDR (arg
));
25576 return HBAR_CURSOR
;
25579 /* Treat anything unknown as "hollow box cursor".
25580 It was bad to signal an error; people have trouble fixing
25581 .Xdefaults with Emacs, when it has something bad in it. */
25582 type
= HOLLOW_BOX_CURSOR
;
25587 /* Set the default cursor types for specified frame. */
25589 set_frame_cursor_types (struct frame
*f
, Lisp_Object arg
)
25594 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
25595 FRAME_CURSOR_WIDTH (f
) = width
;
25597 /* By default, set up the blink-off state depending on the on-state. */
25599 tem
= Fassoc (arg
, Vblink_cursor_alist
);
25602 FRAME_BLINK_OFF_CURSOR (f
)
25603 = get_specified_cursor_type (XCDR (tem
), &width
);
25604 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
25607 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
25611 #ifdef HAVE_WINDOW_SYSTEM
25613 /* Return the cursor we want to be displayed in window W. Return
25614 width of bar/hbar cursor through WIDTH arg. Return with
25615 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
25616 (i.e. if the `system caret' should track this cursor).
25618 In a mini-buffer window, we want the cursor only to appear if we
25619 are reading input from this window. For the selected window, we
25620 want the cursor type given by the frame parameter or buffer local
25621 setting of cursor-type. If explicitly marked off, draw no cursor.
25622 In all other cases, we want a hollow box cursor. */
25624 static enum text_cursor_kinds
25625 get_window_cursor_type (struct window
*w
, struct glyph
*glyph
, int *width
,
25626 int *active_cursor
)
25628 struct frame
*f
= XFRAME (w
->frame
);
25629 struct buffer
*b
= XBUFFER (w
->buffer
);
25630 int cursor_type
= DEFAULT_CURSOR
;
25631 Lisp_Object alt_cursor
;
25632 int non_selected
= 0;
25634 *active_cursor
= 1;
25637 if (cursor_in_echo_area
25638 && FRAME_HAS_MINIBUF_P (f
)
25639 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
25641 if (w
== XWINDOW (echo_area_window
))
25643 if (EQ (BVAR (b
, cursor_type
), Qt
) || NILP (BVAR (b
, cursor_type
)))
25645 *width
= FRAME_CURSOR_WIDTH (f
);
25646 return FRAME_DESIRED_CURSOR (f
);
25649 return get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
25652 *active_cursor
= 0;
25656 /* Detect a nonselected window or nonselected frame. */
25657 else if (w
!= XWINDOW (f
->selected_window
)
25658 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
25660 *active_cursor
= 0;
25662 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
25668 /* Never display a cursor in a window in which cursor-type is nil. */
25669 if (NILP (BVAR (b
, cursor_type
)))
25672 /* Get the normal cursor type for this window. */
25673 if (EQ (BVAR (b
, cursor_type
), Qt
))
25675 cursor_type
= FRAME_DESIRED_CURSOR (f
);
25676 *width
= FRAME_CURSOR_WIDTH (f
);
25679 cursor_type
= get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
25681 /* Use cursor-in-non-selected-windows instead
25682 for non-selected window or frame. */
25685 alt_cursor
= BVAR (b
, cursor_in_non_selected_windows
);
25686 if (!EQ (Qt
, alt_cursor
))
25687 return get_specified_cursor_type (alt_cursor
, width
);
25688 /* t means modify the normal cursor type. */
25689 if (cursor_type
== FILLED_BOX_CURSOR
)
25690 cursor_type
= HOLLOW_BOX_CURSOR
;
25691 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
25693 return cursor_type
;
25696 /* Use normal cursor if not blinked off. */
25697 if (!w
->cursor_off_p
)
25699 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
25701 if (cursor_type
== FILLED_BOX_CURSOR
)
25703 /* Using a block cursor on large images can be very annoying.
25704 So use a hollow cursor for "large" images.
25705 If image is not transparent (no mask), also use hollow cursor. */
25706 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
25707 if (img
!= NULL
&& IMAGEP (img
->spec
))
25709 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
25710 where N = size of default frame font size.
25711 This should cover most of the "tiny" icons people may use. */
25713 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
25714 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
25715 cursor_type
= HOLLOW_BOX_CURSOR
;
25718 else if (cursor_type
!= NO_CURSOR
)
25720 /* Display current only supports BOX and HOLLOW cursors for images.
25721 So for now, unconditionally use a HOLLOW cursor when cursor is
25722 not a solid box cursor. */
25723 cursor_type
= HOLLOW_BOX_CURSOR
;
25726 return cursor_type
;
25729 /* Cursor is blinked off, so determine how to "toggle" it. */
25731 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
25732 if ((alt_cursor
= Fassoc (BVAR (b
, cursor_type
), Vblink_cursor_alist
), !NILP (alt_cursor
)))
25733 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
25735 /* Then see if frame has specified a specific blink off cursor type. */
25736 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
25738 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
25739 return FRAME_BLINK_OFF_CURSOR (f
);
25743 /* Some people liked having a permanently visible blinking cursor,
25744 while others had very strong opinions against it. So it was
25745 decided to remove it. KFS 2003-09-03 */
25747 /* Finally perform built-in cursor blinking:
25748 filled box <-> hollow box
25749 wide [h]bar <-> narrow [h]bar
25750 narrow [h]bar <-> no cursor
25751 other type <-> no cursor */
25753 if (cursor_type
== FILLED_BOX_CURSOR
)
25754 return HOLLOW_BOX_CURSOR
;
25756 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
25759 return cursor_type
;
25767 /* Notice when the text cursor of window W has been completely
25768 overwritten by a drawing operation that outputs glyphs in AREA
25769 starting at X0 and ending at X1 in the line starting at Y0 and
25770 ending at Y1. X coordinates are area-relative. X1 < 0 means all
25771 the rest of the line after X0 has been written. Y coordinates
25772 are window-relative. */
25775 notice_overwritten_cursor (struct window
*w
, enum glyph_row_area area
,
25776 int x0
, int x1
, int y0
, int y1
)
25778 int cx0
, cx1
, cy0
, cy1
;
25779 struct glyph_row
*row
;
25781 if (!w
->phys_cursor_on_p
)
25783 if (area
!= TEXT_AREA
)
25786 if (w
->phys_cursor
.vpos
< 0
25787 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
25788 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
25789 !(row
->enabled_p
&& row
->displays_text_p
)))
25792 if (row
->cursor_in_fringe_p
)
25794 row
->cursor_in_fringe_p
= 0;
25795 draw_fringe_bitmap (w
, row
, row
->reversed_p
);
25796 w
->phys_cursor_on_p
= 0;
25800 cx0
= w
->phys_cursor
.x
;
25801 cx1
= cx0
+ w
->phys_cursor_width
;
25802 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
25805 /* The cursor image will be completely removed from the
25806 screen if the output area intersects the cursor area in
25807 y-direction. When we draw in [y0 y1[, and some part of
25808 the cursor is at y < y0, that part must have been drawn
25809 before. When scrolling, the cursor is erased before
25810 actually scrolling, so we don't come here. When not
25811 scrolling, the rows above the old cursor row must have
25812 changed, and in this case these rows must have written
25813 over the cursor image.
25815 Likewise if part of the cursor is below y1, with the
25816 exception of the cursor being in the first blank row at
25817 the buffer and window end because update_text_area
25818 doesn't draw that row. (Except when it does, but
25819 that's handled in update_text_area.) */
25821 cy0
= w
->phys_cursor
.y
;
25822 cy1
= cy0
+ w
->phys_cursor_height
;
25823 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
25826 w
->phys_cursor_on_p
= 0;
25829 #endif /* HAVE_WINDOW_SYSTEM */
25832 /************************************************************************
25834 ************************************************************************/
25836 #ifdef HAVE_WINDOW_SYSTEM
25839 Fix the display of area AREA of overlapping row ROW in window W
25840 with respect to the overlapping part OVERLAPS. */
25843 x_fix_overlapping_area (struct window
*w
, struct glyph_row
*row
,
25844 enum glyph_row_area area
, int overlaps
)
25851 for (i
= 0; i
< row
->used
[area
];)
25853 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
25855 int start
= i
, start_x
= x
;
25859 x
+= row
->glyphs
[area
][i
].pixel_width
;
25862 while (i
< row
->used
[area
]
25863 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
25865 draw_glyphs (w
, start_x
, row
, area
,
25867 DRAW_NORMAL_TEXT
, overlaps
);
25871 x
+= row
->glyphs
[area
][i
].pixel_width
;
25881 Draw the cursor glyph of window W in glyph row ROW. See the
25882 comment of draw_glyphs for the meaning of HL. */
25885 draw_phys_cursor_glyph (struct window
*w
, struct glyph_row
*row
,
25886 enum draw_glyphs_face hl
)
25888 /* If cursor hpos is out of bounds, don't draw garbage. This can
25889 happen in mini-buffer windows when switching between echo area
25890 glyphs and mini-buffer. */
25891 if ((row
->reversed_p
25892 ? (w
->phys_cursor
.hpos
>= 0)
25893 : (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])))
25895 int on_p
= w
->phys_cursor_on_p
;
25897 int hpos
= w
->phys_cursor
.hpos
;
25899 /* When the window is hscrolled, cursor hpos can legitimately be
25900 out of bounds, but we draw the cursor at the corresponding
25901 window margin in that case. */
25902 if (!row
->reversed_p
&& hpos
< 0)
25904 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
25905 hpos
= row
->used
[TEXT_AREA
] - 1;
25907 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
, hpos
, hpos
+ 1,
25909 w
->phys_cursor_on_p
= on_p
;
25911 if (hl
== DRAW_CURSOR
)
25912 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
25913 /* When we erase the cursor, and ROW is overlapped by other
25914 rows, make sure that these overlapping parts of other rows
25916 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
25918 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
25920 if (row
> w
->current_matrix
->rows
25921 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
25922 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
25923 OVERLAPS_ERASED_CURSOR
);
25925 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
25926 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
25927 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
25928 OVERLAPS_ERASED_CURSOR
);
25935 Erase the image of a cursor of window W from the screen. */
25938 erase_phys_cursor (struct window
*w
)
25940 struct frame
*f
= XFRAME (w
->frame
);
25941 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25942 int hpos
= w
->phys_cursor
.hpos
;
25943 int vpos
= w
->phys_cursor
.vpos
;
25944 int mouse_face_here_p
= 0;
25945 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
25946 struct glyph_row
*cursor_row
;
25947 struct glyph
*cursor_glyph
;
25948 enum draw_glyphs_face hl
;
25950 /* No cursor displayed or row invalidated => nothing to do on the
25952 if (w
->phys_cursor_type
== NO_CURSOR
)
25953 goto mark_cursor_off
;
25955 /* VPOS >= active_glyphs->nrows means that window has been resized.
25956 Don't bother to erase the cursor. */
25957 if (vpos
>= active_glyphs
->nrows
)
25958 goto mark_cursor_off
;
25960 /* If row containing cursor is marked invalid, there is nothing we
25962 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
25963 if (!cursor_row
->enabled_p
)
25964 goto mark_cursor_off
;
25966 /* If line spacing is > 0, old cursor may only be partially visible in
25967 window after split-window. So adjust visible height. */
25968 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
25969 window_text_bottom_y (w
) - cursor_row
->y
);
25971 /* If row is completely invisible, don't attempt to delete a cursor which
25972 isn't there. This can happen if cursor is at top of a window, and
25973 we switch to a buffer with a header line in that window. */
25974 if (cursor_row
->visible_height
<= 0)
25975 goto mark_cursor_off
;
25977 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
25978 if (cursor_row
->cursor_in_fringe_p
)
25980 cursor_row
->cursor_in_fringe_p
= 0;
25981 draw_fringe_bitmap (w
, cursor_row
, cursor_row
->reversed_p
);
25982 goto mark_cursor_off
;
25985 /* This can happen when the new row is shorter than the old one.
25986 In this case, either draw_glyphs or clear_end_of_line
25987 should have cleared the cursor. Note that we wouldn't be
25988 able to erase the cursor in this case because we don't have a
25989 cursor glyph at hand. */
25990 if ((cursor_row
->reversed_p
25991 ? (w
->phys_cursor
.hpos
< 0)
25992 : (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])))
25993 goto mark_cursor_off
;
25995 /* When the window is hscrolled, cursor hpos can legitimately be out
25996 of bounds, but we draw the cursor at the corresponding window
25997 margin in that case. */
25998 if (!cursor_row
->reversed_p
&& hpos
< 0)
26000 if (cursor_row
->reversed_p
&& hpos
>= cursor_row
->used
[TEXT_AREA
])
26001 hpos
= cursor_row
->used
[TEXT_AREA
] - 1;
26003 /* If the cursor is in the mouse face area, redisplay that when
26004 we clear the cursor. */
26005 if (! NILP (hlinfo
->mouse_face_window
)
26006 && coords_in_mouse_face_p (w
, hpos
, vpos
)
26007 /* Don't redraw the cursor's spot in mouse face if it is at the
26008 end of a line (on a newline). The cursor appears there, but
26009 mouse highlighting does not. */
26010 && cursor_row
->used
[TEXT_AREA
] > hpos
&& hpos
>= 0)
26011 mouse_face_here_p
= 1;
26013 /* Maybe clear the display under the cursor. */
26014 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
26017 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
26020 cursor_glyph
= get_phys_cursor_glyph (w
);
26021 if (cursor_glyph
== NULL
)
26022 goto mark_cursor_off
;
26024 width
= cursor_glyph
->pixel_width
;
26025 left_x
= window_box_left_offset (w
, TEXT_AREA
);
26026 x
= w
->phys_cursor
.x
;
26028 width
-= left_x
- x
;
26029 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
26030 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
26031 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
26034 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
26037 /* Erase the cursor by redrawing the character underneath it. */
26038 if (mouse_face_here_p
)
26039 hl
= DRAW_MOUSE_FACE
;
26041 hl
= DRAW_NORMAL_TEXT
;
26042 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
26045 w
->phys_cursor_on_p
= 0;
26046 w
->phys_cursor_type
= NO_CURSOR
;
26051 Display or clear cursor of window W. If ON is zero, clear the
26052 cursor. If it is non-zero, display the cursor. If ON is nonzero,
26053 where to put the cursor is specified by HPOS, VPOS, X and Y. */
26056 display_and_set_cursor (struct window
*w
, int on
,
26057 int hpos
, int vpos
, int x
, int y
)
26059 struct frame
*f
= XFRAME (w
->frame
);
26060 int new_cursor_type
;
26061 int new_cursor_width
;
26063 struct glyph_row
*glyph_row
;
26064 struct glyph
*glyph
;
26066 /* This is pointless on invisible frames, and dangerous on garbaged
26067 windows and frames; in the latter case, the frame or window may
26068 be in the midst of changing its size, and x and y may be off the
26070 if (! FRAME_VISIBLE_P (f
)
26071 || FRAME_GARBAGED_P (f
)
26072 || vpos
>= w
->current_matrix
->nrows
26073 || hpos
>= w
->current_matrix
->matrix_w
)
26076 /* If cursor is off and we want it off, return quickly. */
26077 if (!on
&& !w
->phys_cursor_on_p
)
26080 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26081 /* If cursor row is not enabled, we don't really know where to
26082 display the cursor. */
26083 if (!glyph_row
->enabled_p
)
26085 w
->phys_cursor_on_p
= 0;
26090 if (!glyph_row
->exact_window_width_line_p
26091 || (0 <= hpos
&& hpos
< glyph_row
->used
[TEXT_AREA
]))
26092 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
26094 eassert (input_blocked_p ());
26096 /* Set new_cursor_type to the cursor we want to be displayed. */
26097 new_cursor_type
= get_window_cursor_type (w
, glyph
,
26098 &new_cursor_width
, &active_cursor
);
26100 /* If cursor is currently being shown and we don't want it to be or
26101 it is in the wrong place, or the cursor type is not what we want,
26103 if (w
->phys_cursor_on_p
26105 || w
->phys_cursor
.x
!= x
26106 || w
->phys_cursor
.y
!= y
26107 || new_cursor_type
!= w
->phys_cursor_type
26108 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
26109 && new_cursor_width
!= w
->phys_cursor_width
)))
26110 erase_phys_cursor (w
);
26112 /* Don't check phys_cursor_on_p here because that flag is only set
26113 to zero in some cases where we know that the cursor has been
26114 completely erased, to avoid the extra work of erasing the cursor
26115 twice. In other words, phys_cursor_on_p can be 1 and the cursor
26116 still not be visible, or it has only been partly erased. */
26119 w
->phys_cursor_ascent
= glyph_row
->ascent
;
26120 w
->phys_cursor_height
= glyph_row
->height
;
26122 /* Set phys_cursor_.* before x_draw_.* is called because some
26123 of them may need the information. */
26124 w
->phys_cursor
.x
= x
;
26125 w
->phys_cursor
.y
= glyph_row
->y
;
26126 w
->phys_cursor
.hpos
= hpos
;
26127 w
->phys_cursor
.vpos
= vpos
;
26130 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
26131 new_cursor_type
, new_cursor_width
,
26132 on
, active_cursor
);
26136 /* Switch the display of W's cursor on or off, according to the value
26140 update_window_cursor (struct window
*w
, int on
)
26142 /* Don't update cursor in windows whose frame is in the process
26143 of being deleted. */
26144 if (w
->current_matrix
)
26146 int hpos
= w
->phys_cursor
.hpos
;
26147 int vpos
= w
->phys_cursor
.vpos
;
26148 struct glyph_row
*row
;
26150 if (vpos
>= w
->current_matrix
->nrows
26151 || hpos
>= w
->current_matrix
->matrix_w
)
26154 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26156 /* When the window is hscrolled, cursor hpos can legitimately be
26157 out of bounds, but we draw the cursor at the corresponding
26158 window margin in that case. */
26159 if (!row
->reversed_p
&& hpos
< 0)
26161 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26162 hpos
= row
->used
[TEXT_AREA
] - 1;
26165 display_and_set_cursor (w
, on
, hpos
, vpos
,
26166 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
26172 /* Call update_window_cursor with parameter ON_P on all leaf windows
26173 in the window tree rooted at W. */
26176 update_cursor_in_window_tree (struct window
*w
, int on_p
)
26180 if (!NILP (w
->hchild
))
26181 update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
26182 else if (!NILP (w
->vchild
))
26183 update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
26185 update_window_cursor (w
, on_p
);
26187 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
26193 Display the cursor on window W, or clear it, according to ON_P.
26194 Don't change the cursor's position. */
26197 x_update_cursor (struct frame
*f
, int on_p
)
26199 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
26204 Clear the cursor of window W to background color, and mark the
26205 cursor as not shown. This is used when the text where the cursor
26206 is about to be rewritten. */
26209 x_clear_cursor (struct window
*w
)
26211 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
26212 update_window_cursor (w
, 0);
26215 #endif /* HAVE_WINDOW_SYSTEM */
26217 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
26220 draw_row_with_mouse_face (struct window
*w
, int start_x
, struct glyph_row
*row
,
26221 int start_hpos
, int end_hpos
,
26222 enum draw_glyphs_face draw
)
26224 #ifdef HAVE_WINDOW_SYSTEM
26225 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
26227 draw_glyphs (w
, start_x
, row
, TEXT_AREA
, start_hpos
, end_hpos
, draw
, 0);
26231 #if defined (HAVE_GPM) || defined (MSDOS) || defined (WINDOWSNT)
26232 tty_draw_row_with_mouse_face (w
, row
, start_hpos
, end_hpos
, draw
);
26236 /* Display the active region described by mouse_face_* according to DRAW. */
26239 show_mouse_face (Mouse_HLInfo
*hlinfo
, enum draw_glyphs_face draw
)
26241 struct window
*w
= XWINDOW (hlinfo
->mouse_face_window
);
26242 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
26244 if (/* If window is in the process of being destroyed, don't bother
26246 w
->current_matrix
!= NULL
26247 /* Don't update mouse highlight if hidden */
26248 && (draw
!= DRAW_MOUSE_FACE
|| !hlinfo
->mouse_face_hidden
)
26249 /* Recognize when we are called to operate on rows that don't exist
26250 anymore. This can happen when a window is split. */
26251 && hlinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
26253 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
26254 struct glyph_row
*row
, *first
, *last
;
26256 first
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
26257 last
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
26259 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
26261 int start_hpos
, end_hpos
, start_x
;
26263 /* For all but the first row, the highlight starts at column 0. */
26266 /* R2L rows have BEG and END in reversed order, but the
26267 screen drawing geometry is always left to right. So
26268 we need to mirror the beginning and end of the
26269 highlighted area in R2L rows. */
26270 if (!row
->reversed_p
)
26272 start_hpos
= hlinfo
->mouse_face_beg_col
;
26273 start_x
= hlinfo
->mouse_face_beg_x
;
26275 else if (row
== last
)
26277 start_hpos
= hlinfo
->mouse_face_end_col
;
26278 start_x
= hlinfo
->mouse_face_end_x
;
26286 else if (row
->reversed_p
&& row
== last
)
26288 start_hpos
= hlinfo
->mouse_face_end_col
;
26289 start_x
= hlinfo
->mouse_face_end_x
;
26299 if (!row
->reversed_p
)
26300 end_hpos
= hlinfo
->mouse_face_end_col
;
26301 else if (row
== first
)
26302 end_hpos
= hlinfo
->mouse_face_beg_col
;
26305 end_hpos
= row
->used
[TEXT_AREA
];
26306 if (draw
== DRAW_NORMAL_TEXT
)
26307 row
->fill_line_p
= 1; /* Clear to end of line */
26310 else if (row
->reversed_p
&& row
== first
)
26311 end_hpos
= hlinfo
->mouse_face_beg_col
;
26314 end_hpos
= row
->used
[TEXT_AREA
];
26315 if (draw
== DRAW_NORMAL_TEXT
)
26316 row
->fill_line_p
= 1; /* Clear to end of line */
26319 if (end_hpos
> start_hpos
)
26321 draw_row_with_mouse_face (w
, start_x
, row
,
26322 start_hpos
, end_hpos
, draw
);
26325 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
26329 #ifdef HAVE_WINDOW_SYSTEM
26330 /* When we've written over the cursor, arrange for it to
26331 be displayed again. */
26332 if (FRAME_WINDOW_P (f
)
26333 && phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
26335 int hpos
= w
->phys_cursor
.hpos
;
26337 /* When the window is hscrolled, cursor hpos can legitimately be
26338 out of bounds, but we draw the cursor at the corresponding
26339 window margin in that case. */
26340 if (!row
->reversed_p
&& hpos
< 0)
26342 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26343 hpos
= row
->used
[TEXT_AREA
] - 1;
26346 display_and_set_cursor (w
, 1, hpos
, w
->phys_cursor
.vpos
,
26347 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
26350 #endif /* HAVE_WINDOW_SYSTEM */
26353 #ifdef HAVE_WINDOW_SYSTEM
26354 /* Change the mouse cursor. */
26355 if (FRAME_WINDOW_P (f
))
26357 if (draw
== DRAW_NORMAL_TEXT
26358 && !EQ (hlinfo
->mouse_face_window
, f
->tool_bar_window
))
26359 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
26360 else if (draw
== DRAW_MOUSE_FACE
)
26361 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
26363 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
26365 #endif /* HAVE_WINDOW_SYSTEM */
26369 Clear out the mouse-highlighted active region.
26370 Redraw it un-highlighted first. Value is non-zero if mouse
26371 face was actually drawn unhighlighted. */
26374 clear_mouse_face (Mouse_HLInfo
*hlinfo
)
26378 if (!hlinfo
->mouse_face_hidden
&& !NILP (hlinfo
->mouse_face_window
))
26380 show_mouse_face (hlinfo
, DRAW_NORMAL_TEXT
);
26384 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
26385 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
26386 hlinfo
->mouse_face_window
= Qnil
;
26387 hlinfo
->mouse_face_overlay
= Qnil
;
26391 /* Return non-zero if the coordinates HPOS and VPOS on windows W are
26392 within the mouse face on that window. */
26394 coords_in_mouse_face_p (struct window
*w
, int hpos
, int vpos
)
26396 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
26398 /* Quickly resolve the easy cases. */
26399 if (!(WINDOWP (hlinfo
->mouse_face_window
)
26400 && XWINDOW (hlinfo
->mouse_face_window
) == w
))
26402 if (vpos
< hlinfo
->mouse_face_beg_row
26403 || vpos
> hlinfo
->mouse_face_end_row
)
26405 if (vpos
> hlinfo
->mouse_face_beg_row
26406 && vpos
< hlinfo
->mouse_face_end_row
)
26409 if (!MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
)
26411 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
26413 if (hlinfo
->mouse_face_beg_col
<= hpos
&& hpos
< hlinfo
->mouse_face_end_col
)
26416 else if ((vpos
== hlinfo
->mouse_face_beg_row
26417 && hpos
>= hlinfo
->mouse_face_beg_col
)
26418 || (vpos
== hlinfo
->mouse_face_end_row
26419 && hpos
< hlinfo
->mouse_face_end_col
))
26424 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
26426 if (hlinfo
->mouse_face_end_col
< hpos
&& hpos
<= hlinfo
->mouse_face_beg_col
)
26429 else if ((vpos
== hlinfo
->mouse_face_beg_row
26430 && hpos
<= hlinfo
->mouse_face_beg_col
)
26431 || (vpos
== hlinfo
->mouse_face_end_row
26432 && hpos
> hlinfo
->mouse_face_end_col
))
26440 Non-zero if physical cursor of window W is within mouse face. */
26443 cursor_in_mouse_face_p (struct window
*w
)
26445 int hpos
= w
->phys_cursor
.hpos
;
26446 int vpos
= w
->phys_cursor
.vpos
;
26447 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26449 /* When the window is hscrolled, cursor hpos can legitimately be out
26450 of bounds, but we draw the cursor at the corresponding window
26451 margin in that case. */
26452 if (!row
->reversed_p
&& hpos
< 0)
26454 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26455 hpos
= row
->used
[TEXT_AREA
] - 1;
26457 return coords_in_mouse_face_p (w
, hpos
, vpos
);
26462 /* Find the glyph rows START_ROW and END_ROW of window W that display
26463 characters between buffer positions START_CHARPOS and END_CHARPOS
26464 (excluding END_CHARPOS). DISP_STRING is a display string that
26465 covers these buffer positions. This is similar to
26466 row_containing_pos, but is more accurate when bidi reordering makes
26467 buffer positions change non-linearly with glyph rows. */
26469 rows_from_pos_range (struct window
*w
,
26470 ptrdiff_t start_charpos
, ptrdiff_t end_charpos
,
26471 Lisp_Object disp_string
,
26472 struct glyph_row
**start
, struct glyph_row
**end
)
26474 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26475 int last_y
= window_text_bottom_y (w
);
26476 struct glyph_row
*row
;
26481 while (!first
->enabled_p
26482 && first
< MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
26485 /* Find the START row. */
26487 row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
;
26490 /* A row can potentially be the START row if the range of the
26491 characters it displays intersects the range
26492 [START_CHARPOS..END_CHARPOS). */
26493 if (! ((start_charpos
< MATRIX_ROW_START_CHARPOS (row
)
26494 && end_charpos
< MATRIX_ROW_START_CHARPOS (row
))
26495 /* See the commentary in row_containing_pos, for the
26496 explanation of the complicated way to check whether
26497 some position is beyond the end of the characters
26498 displayed by a row. */
26499 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (row
)
26500 || (start_charpos
== MATRIX_ROW_END_CHARPOS (row
)
26501 && !row
->ends_at_zv_p
26502 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
26503 && (end_charpos
> MATRIX_ROW_END_CHARPOS (row
)
26504 || (end_charpos
== MATRIX_ROW_END_CHARPOS (row
)
26505 && !row
->ends_at_zv_p
26506 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))))
26508 /* Found a candidate row. Now make sure at least one of the
26509 glyphs it displays has a charpos from the range
26510 [START_CHARPOS..END_CHARPOS).
26512 This is not obvious because bidi reordering could make
26513 buffer positions of a row be 1,2,3,102,101,100, and if we
26514 want to highlight characters in [50..60), we don't want
26515 this row, even though [50..60) does intersect [1..103),
26516 the range of character positions given by the row's start
26517 and end positions. */
26518 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
26519 struct glyph
*e
= g
+ row
->used
[TEXT_AREA
];
26523 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
26524 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
26525 /* A glyph that comes from DISP_STRING is by
26526 definition to be highlighted. */
26527 || EQ (g
->object
, disp_string
))
26536 /* Find the END row. */
26538 /* If the last row is partially visible, start looking for END
26539 from that row, instead of starting from FIRST. */
26540 && !(row
->enabled_p
26541 && row
->y
< last_y
&& MATRIX_ROW_BOTTOM_Y (row
) > last_y
))
26543 for ( ; row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
; row
++)
26545 struct glyph_row
*next
= row
+ 1;
26546 ptrdiff_t next_start
= MATRIX_ROW_START_CHARPOS (next
);
26548 if (!next
->enabled_p
26549 || next
>= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
)
26550 /* The first row >= START whose range of displayed characters
26551 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
26552 is the row END + 1. */
26553 || (start_charpos
< next_start
26554 && end_charpos
< next_start
)
26555 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (next
)
26556 || (start_charpos
== MATRIX_ROW_END_CHARPOS (next
)
26557 && !next
->ends_at_zv_p
26558 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))
26559 && (end_charpos
> MATRIX_ROW_END_CHARPOS (next
)
26560 || (end_charpos
== MATRIX_ROW_END_CHARPOS (next
)
26561 && !next
->ends_at_zv_p
26562 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))))
26569 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
26570 but none of the characters it displays are in the range, it is
26572 struct glyph
*g
= next
->glyphs
[TEXT_AREA
];
26573 struct glyph
*s
= g
;
26574 struct glyph
*e
= g
+ next
->used
[TEXT_AREA
];
26578 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
26579 && ((start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
26580 /* If the buffer position of the first glyph in
26581 the row is equal to END_CHARPOS, it means
26582 the last character to be highlighted is the
26583 newline of ROW, and we must consider NEXT as
26585 || (((!next
->reversed_p
&& g
== s
)
26586 || (next
->reversed_p
&& g
== e
- 1))
26587 && (g
->charpos
== end_charpos
26588 /* Special case for when NEXT is an
26589 empty line at ZV. */
26590 || (g
->charpos
== -1
26591 && !row
->ends_at_zv_p
26592 && next_start
== end_charpos
)))))
26593 /* A glyph that comes from DISP_STRING is by
26594 definition to be highlighted. */
26595 || EQ (g
->object
, disp_string
))
26604 /* The first row that ends at ZV must be the last to be
26606 else if (next
->ends_at_zv_p
)
26615 /* This function sets the mouse_face_* elements of HLINFO, assuming
26616 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
26617 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
26618 for the overlay or run of text properties specifying the mouse
26619 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
26620 before-string and after-string that must also be highlighted.
26621 DISP_STRING, if non-nil, is a display string that may cover some
26622 or all of the highlighted text. */
26625 mouse_face_from_buffer_pos (Lisp_Object window
,
26626 Mouse_HLInfo
*hlinfo
,
26627 ptrdiff_t mouse_charpos
,
26628 ptrdiff_t start_charpos
,
26629 ptrdiff_t end_charpos
,
26630 Lisp_Object before_string
,
26631 Lisp_Object after_string
,
26632 Lisp_Object disp_string
)
26634 struct window
*w
= XWINDOW (window
);
26635 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26636 struct glyph_row
*r1
, *r2
;
26637 struct glyph
*glyph
, *end
;
26638 ptrdiff_t ignore
, pos
;
26641 eassert (NILP (disp_string
) || STRINGP (disp_string
));
26642 eassert (NILP (before_string
) || STRINGP (before_string
));
26643 eassert (NILP (after_string
) || STRINGP (after_string
));
26645 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
26646 rows_from_pos_range (w
, start_charpos
, end_charpos
, disp_string
, &r1
, &r2
);
26648 r1
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26649 /* If the before-string or display-string contains newlines,
26650 rows_from_pos_range skips to its last row. Move back. */
26651 if (!NILP (before_string
) || !NILP (disp_string
))
26653 struct glyph_row
*prev
;
26654 while ((prev
= r1
- 1, prev
>= first
)
26655 && MATRIX_ROW_END_CHARPOS (prev
) == start_charpos
26656 && prev
->used
[TEXT_AREA
] > 0)
26658 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
26659 glyph
= beg
+ prev
->used
[TEXT_AREA
];
26660 while (--glyph
>= beg
&& INTEGERP (glyph
->object
));
26662 || !(EQ (glyph
->object
, before_string
)
26663 || EQ (glyph
->object
, disp_string
)))
26670 r2
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26671 hlinfo
->mouse_face_past_end
= 1;
26673 else if (!NILP (after_string
))
26675 /* If the after-string has newlines, advance to its last row. */
26676 struct glyph_row
*next
;
26677 struct glyph_row
*last
26678 = MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26680 for (next
= r2
+ 1;
26682 && next
->used
[TEXT_AREA
] > 0
26683 && EQ (next
->glyphs
[TEXT_AREA
]->object
, after_string
);
26687 /* The rest of the display engine assumes that mouse_face_beg_row is
26688 either above mouse_face_end_row or identical to it. But with
26689 bidi-reordered continued lines, the row for START_CHARPOS could
26690 be below the row for END_CHARPOS. If so, swap the rows and store
26691 them in correct order. */
26694 struct glyph_row
*tem
= r2
;
26700 hlinfo
->mouse_face_beg_y
= r1
->y
;
26701 hlinfo
->mouse_face_beg_row
= MATRIX_ROW_VPOS (r1
, w
->current_matrix
);
26702 hlinfo
->mouse_face_end_y
= r2
->y
;
26703 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r2
, w
->current_matrix
);
26705 /* For a bidi-reordered row, the positions of BEFORE_STRING,
26706 AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
26707 could be anywhere in the row and in any order. The strategy
26708 below is to find the leftmost and the rightmost glyph that
26709 belongs to either of these 3 strings, or whose position is
26710 between START_CHARPOS and END_CHARPOS, and highlight all the
26711 glyphs between those two. This may cover more than just the text
26712 between START_CHARPOS and END_CHARPOS if the range of characters
26713 strides the bidi level boundary, e.g. if the beginning is in R2L
26714 text while the end is in L2R text or vice versa. */
26715 if (!r1
->reversed_p
)
26717 /* This row is in a left to right paragraph. Scan it left to
26719 glyph
= r1
->glyphs
[TEXT_AREA
];
26720 end
= glyph
+ r1
->used
[TEXT_AREA
];
26723 /* Skip truncation glyphs at the start of the glyph row. */
26724 if (r1
->displays_text_p
)
26726 && INTEGERP (glyph
->object
)
26727 && glyph
->charpos
< 0;
26729 x
+= glyph
->pixel_width
;
26731 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
26732 or DISP_STRING, and the first glyph from buffer whose
26733 position is between START_CHARPOS and END_CHARPOS. */
26735 && !INTEGERP (glyph
->object
)
26736 && !EQ (glyph
->object
, disp_string
)
26737 && !(BUFFERP (glyph
->object
)
26738 && (glyph
->charpos
>= start_charpos
26739 && glyph
->charpos
< end_charpos
));
26742 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26743 are present at buffer positions between START_CHARPOS and
26744 END_CHARPOS, or if they come from an overlay. */
26745 if (EQ (glyph
->object
, before_string
))
26747 pos
= string_buffer_position (before_string
,
26749 /* If pos == 0, it means before_string came from an
26750 overlay, not from a buffer position. */
26751 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26754 else if (EQ (glyph
->object
, after_string
))
26756 pos
= string_buffer_position (after_string
, end_charpos
);
26757 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26760 x
+= glyph
->pixel_width
;
26762 hlinfo
->mouse_face_beg_x
= x
;
26763 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
26767 /* This row is in a right to left paragraph. Scan it right to
26771 end
= r1
->glyphs
[TEXT_AREA
] - 1;
26772 glyph
= end
+ r1
->used
[TEXT_AREA
];
26774 /* Skip truncation glyphs at the start of the glyph row. */
26775 if (r1
->displays_text_p
)
26777 && INTEGERP (glyph
->object
)
26778 && glyph
->charpos
< 0;
26782 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
26783 or DISP_STRING, and the first glyph from buffer whose
26784 position is between START_CHARPOS and END_CHARPOS. */
26786 && !INTEGERP (glyph
->object
)
26787 && !EQ (glyph
->object
, disp_string
)
26788 && !(BUFFERP (glyph
->object
)
26789 && (glyph
->charpos
>= start_charpos
26790 && glyph
->charpos
< end_charpos
));
26793 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26794 are present at buffer positions between START_CHARPOS and
26795 END_CHARPOS, or if they come from an overlay. */
26796 if (EQ (glyph
->object
, before_string
))
26798 pos
= string_buffer_position (before_string
, start_charpos
);
26799 /* If pos == 0, it means before_string came from an
26800 overlay, not from a buffer position. */
26801 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26804 else if (EQ (glyph
->object
, after_string
))
26806 pos
= string_buffer_position (after_string
, end_charpos
);
26807 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26812 glyph
++; /* first glyph to the right of the highlighted area */
26813 for (g
= r1
->glyphs
[TEXT_AREA
], x
= r1
->x
; g
< glyph
; g
++)
26814 x
+= g
->pixel_width
;
26815 hlinfo
->mouse_face_beg_x
= x
;
26816 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
26819 /* If the highlight ends in a different row, compute GLYPH and END
26820 for the end row. Otherwise, reuse the values computed above for
26821 the row where the highlight begins. */
26824 if (!r2
->reversed_p
)
26826 glyph
= r2
->glyphs
[TEXT_AREA
];
26827 end
= glyph
+ r2
->used
[TEXT_AREA
];
26832 end
= r2
->glyphs
[TEXT_AREA
] - 1;
26833 glyph
= end
+ r2
->used
[TEXT_AREA
];
26837 if (!r2
->reversed_p
)
26839 /* Skip truncation and continuation glyphs near the end of the
26840 row, and also blanks and stretch glyphs inserted by
26841 extend_face_to_end_of_line. */
26843 && INTEGERP ((end
- 1)->object
))
26845 /* Scan the rest of the glyph row from the end, looking for the
26846 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26847 DISP_STRING, or whose position is between START_CHARPOS
26851 && !INTEGERP (end
->object
)
26852 && !EQ (end
->object
, disp_string
)
26853 && !(BUFFERP (end
->object
)
26854 && (end
->charpos
>= start_charpos
26855 && end
->charpos
< end_charpos
));
26858 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26859 are present at buffer positions between START_CHARPOS and
26860 END_CHARPOS, or if they come from an overlay. */
26861 if (EQ (end
->object
, before_string
))
26863 pos
= string_buffer_position (before_string
, start_charpos
);
26864 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26867 else if (EQ (end
->object
, after_string
))
26869 pos
= string_buffer_position (after_string
, end_charpos
);
26870 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26874 /* Find the X coordinate of the last glyph to be highlighted. */
26875 for (; glyph
<= end
; ++glyph
)
26876 x
+= glyph
->pixel_width
;
26878 hlinfo
->mouse_face_end_x
= x
;
26879 hlinfo
->mouse_face_end_col
= glyph
- r2
->glyphs
[TEXT_AREA
];
26883 /* Skip truncation and continuation glyphs near the end of the
26884 row, and also blanks and stretch glyphs inserted by
26885 extend_face_to_end_of_line. */
26889 && INTEGERP (end
->object
))
26891 x
+= end
->pixel_width
;
26894 /* Scan the rest of the glyph row from the end, looking for the
26895 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26896 DISP_STRING, or whose position is between START_CHARPOS
26900 && !INTEGERP (end
->object
)
26901 && !EQ (end
->object
, disp_string
)
26902 && !(BUFFERP (end
->object
)
26903 && (end
->charpos
>= start_charpos
26904 && end
->charpos
< end_charpos
));
26907 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26908 are present at buffer positions between START_CHARPOS and
26909 END_CHARPOS, or if they come from an overlay. */
26910 if (EQ (end
->object
, before_string
))
26912 pos
= string_buffer_position (before_string
, start_charpos
);
26913 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26916 else if (EQ (end
->object
, after_string
))
26918 pos
= string_buffer_position (after_string
, end_charpos
);
26919 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26922 x
+= end
->pixel_width
;
26924 /* If we exited the above loop because we arrived at the last
26925 glyph of the row, and its buffer position is still not in
26926 range, it means the last character in range is the preceding
26927 newline. Bump the end column and x values to get past the
26930 && BUFFERP (end
->object
)
26931 && (end
->charpos
< start_charpos
26932 || end
->charpos
>= end_charpos
))
26934 x
+= end
->pixel_width
;
26937 hlinfo
->mouse_face_end_x
= x
;
26938 hlinfo
->mouse_face_end_col
= end
- r2
->glyphs
[TEXT_AREA
];
26941 hlinfo
->mouse_face_window
= window
;
26942 hlinfo
->mouse_face_face_id
26943 = face_at_buffer_position (w
, mouse_charpos
, 0, 0, &ignore
,
26945 !hlinfo
->mouse_face_hidden
, -1);
26946 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
26949 /* The following function is not used anymore (replaced with
26950 mouse_face_from_string_pos), but I leave it here for the time
26951 being, in case someone would. */
26953 #if 0 /* not used */
26955 /* Find the position of the glyph for position POS in OBJECT in
26956 window W's current matrix, and return in *X, *Y the pixel
26957 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
26959 RIGHT_P non-zero means return the position of the right edge of the
26960 glyph, RIGHT_P zero means return the left edge position.
26962 If no glyph for POS exists in the matrix, return the position of
26963 the glyph with the next smaller position that is in the matrix, if
26964 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
26965 exists in the matrix, return the position of the glyph with the
26966 next larger position in OBJECT.
26968 Value is non-zero if a glyph was found. */
26971 fast_find_string_pos (struct window
*w
, ptrdiff_t pos
, Lisp_Object object
,
26972 int *hpos
, int *vpos
, int *x
, int *y
, int right_p
)
26974 int yb
= window_text_bottom_y (w
);
26975 struct glyph_row
*r
;
26976 struct glyph
*best_glyph
= NULL
;
26977 struct glyph_row
*best_row
= NULL
;
26980 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26981 r
->enabled_p
&& r
->y
< yb
;
26984 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
26985 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
26988 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
26989 if (EQ (g
->object
, object
))
26991 if (g
->charpos
== pos
)
26998 else if (best_glyph
== NULL
26999 || ((eabs (g
->charpos
- pos
)
27000 < eabs (best_glyph
->charpos
- pos
))
27003 : g
->charpos
> pos
)))
27017 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
27021 *x
+= best_glyph
->pixel_width
;
27026 *vpos
= best_row
- w
->current_matrix
->rows
;
27029 return best_glyph
!= NULL
;
27031 #endif /* not used */
27033 /* Find the positions of the first and the last glyphs in window W's
27034 current matrix that occlude positions [STARTPOS..ENDPOS] in OBJECT
27035 (assumed to be a string), and return in HLINFO's mouse_face_*
27036 members the pixel and column/row coordinates of those glyphs. */
27039 mouse_face_from_string_pos (struct window
*w
, Mouse_HLInfo
*hlinfo
,
27040 Lisp_Object object
,
27041 ptrdiff_t startpos
, ptrdiff_t endpos
)
27043 int yb
= window_text_bottom_y (w
);
27044 struct glyph_row
*r
;
27045 struct glyph
*g
, *e
;
27049 /* Find the glyph row with at least one position in the range
27050 [STARTPOS..ENDPOS], and the first glyph in that row whose
27051 position belongs to that range. */
27052 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
27053 r
->enabled_p
&& r
->y
< yb
;
27056 if (!r
->reversed_p
)
27058 g
= r
->glyphs
[TEXT_AREA
];
27059 e
= g
+ r
->used
[TEXT_AREA
];
27060 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
27061 if (EQ (g
->object
, object
)
27062 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
27064 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
27065 hlinfo
->mouse_face_beg_y
= r
->y
;
27066 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
27067 hlinfo
->mouse_face_beg_x
= gx
;
27076 e
= r
->glyphs
[TEXT_AREA
];
27077 g
= e
+ r
->used
[TEXT_AREA
];
27078 for ( ; g
> e
; --g
)
27079 if (EQ ((g
-1)->object
, object
)
27080 && startpos
<= (g
-1)->charpos
&& (g
-1)->charpos
<= endpos
)
27082 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
27083 hlinfo
->mouse_face_beg_y
= r
->y
;
27084 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
27085 for (gx
= r
->x
, g1
= r
->glyphs
[TEXT_AREA
]; g1
< g
; ++g1
)
27086 gx
+= g1
->pixel_width
;
27087 hlinfo
->mouse_face_beg_x
= gx
;
27099 /* Starting with the next row, look for the first row which does NOT
27100 include any glyphs whose positions are in the range. */
27101 for (++r
; r
->enabled_p
&& r
->y
< yb
; ++r
)
27103 g
= r
->glyphs
[TEXT_AREA
];
27104 e
= g
+ r
->used
[TEXT_AREA
];
27106 for ( ; g
< e
; ++g
)
27107 if (EQ (g
->object
, object
)
27108 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
27117 /* The highlighted region ends on the previous row. */
27120 /* Set the end row and its vertical pixel coordinate. */
27121 hlinfo
->mouse_face_end_row
= r
- w
->current_matrix
->rows
;
27122 hlinfo
->mouse_face_end_y
= r
->y
;
27124 /* Compute and set the end column and the end column's horizontal
27125 pixel coordinate. */
27126 if (!r
->reversed_p
)
27128 g
= r
->glyphs
[TEXT_AREA
];
27129 e
= g
+ r
->used
[TEXT_AREA
];
27130 for ( ; e
> g
; --e
)
27131 if (EQ ((e
-1)->object
, object
)
27132 && startpos
<= (e
-1)->charpos
&& (e
-1)->charpos
<= endpos
)
27134 hlinfo
->mouse_face_end_col
= e
- g
;
27136 for (gx
= r
->x
; g
< e
; ++g
)
27137 gx
+= g
->pixel_width
;
27138 hlinfo
->mouse_face_end_x
= gx
;
27142 e
= r
->glyphs
[TEXT_AREA
];
27143 g
= e
+ r
->used
[TEXT_AREA
];
27144 for (gx
= r
->x
; e
< g
; ++e
)
27146 if (EQ (e
->object
, object
)
27147 && startpos
<= e
->charpos
&& e
->charpos
<= endpos
)
27149 gx
+= e
->pixel_width
;
27151 hlinfo
->mouse_face_end_col
= e
- r
->glyphs
[TEXT_AREA
];
27152 hlinfo
->mouse_face_end_x
= gx
;
27156 #ifdef HAVE_WINDOW_SYSTEM
27158 /* See if position X, Y is within a hot-spot of an image. */
27161 on_hot_spot_p (Lisp_Object hot_spot
, int x
, int y
)
27163 if (!CONSP (hot_spot
))
27166 if (EQ (XCAR (hot_spot
), Qrect
))
27168 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
27169 Lisp_Object rect
= XCDR (hot_spot
);
27173 if (!CONSP (XCAR (rect
)))
27175 if (!CONSP (XCDR (rect
)))
27177 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
27179 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
27181 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
27183 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
27187 else if (EQ (XCAR (hot_spot
), Qcircle
))
27189 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
27190 Lisp_Object circ
= XCDR (hot_spot
);
27191 Lisp_Object lr
, lx0
, ly0
;
27193 && CONSP (XCAR (circ
))
27194 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
27195 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
27196 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
27198 double r
= XFLOATINT (lr
);
27199 double dx
= XINT (lx0
) - x
;
27200 double dy
= XINT (ly0
) - y
;
27201 return (dx
* dx
+ dy
* dy
<= r
* r
);
27204 else if (EQ (XCAR (hot_spot
), Qpoly
))
27206 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
27207 if (VECTORP (XCDR (hot_spot
)))
27209 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
27210 Lisp_Object
*poly
= v
->contents
;
27211 ptrdiff_t n
= v
->header
.size
;
27214 Lisp_Object lx
, ly
;
27217 /* Need an even number of coordinates, and at least 3 edges. */
27218 if (n
< 6 || n
& 1)
27221 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
27222 If count is odd, we are inside polygon. Pixels on edges
27223 may or may not be included depending on actual geometry of the
27225 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
27226 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
27228 x0
= XINT (lx
), y0
= XINT (ly
);
27229 for (i
= 0; i
< n
; i
+= 2)
27231 int x1
= x0
, y1
= y0
;
27232 if ((lx
= poly
[i
], !INTEGERP (lx
))
27233 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
27235 x0
= XINT (lx
), y0
= XINT (ly
);
27237 /* Does this segment cross the X line? */
27245 if (y
> y0
&& y
> y1
)
27247 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
27257 find_hot_spot (Lisp_Object map
, int x
, int y
)
27259 while (CONSP (map
))
27261 if (CONSP (XCAR (map
))
27262 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
27270 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
27272 doc
: /* Lookup in image map MAP coordinates X and Y.
27273 An image map is an alist where each element has the format (AREA ID PLIST).
27274 An AREA is specified as either a rectangle, a circle, or a polygon:
27275 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
27276 pixel coordinates of the upper left and bottom right corners.
27277 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
27278 and the radius of the circle; r may be a float or integer.
27279 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
27280 vector describes one corner in the polygon.
27281 Returns the alist element for the first matching AREA in MAP. */)
27282 (Lisp_Object map
, Lisp_Object x
, Lisp_Object y
)
27290 return find_hot_spot (map
,
27291 clip_to_bounds (INT_MIN
, XINT (x
), INT_MAX
),
27292 clip_to_bounds (INT_MIN
, XINT (y
), INT_MAX
));
27296 /* Display frame CURSOR, optionally using shape defined by POINTER. */
27298 define_frame_cursor1 (struct frame
*f
, Cursor cursor
, Lisp_Object pointer
)
27300 /* Do not change cursor shape while dragging mouse. */
27301 if (!NILP (do_mouse_tracking
))
27304 if (!NILP (pointer
))
27306 if (EQ (pointer
, Qarrow
))
27307 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27308 else if (EQ (pointer
, Qhand
))
27309 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
27310 else if (EQ (pointer
, Qtext
))
27311 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
27312 else if (EQ (pointer
, intern ("hdrag")))
27313 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
27314 #ifdef HAVE_X_WINDOWS
27315 else if (EQ (pointer
, intern ("vdrag")))
27316 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
27318 else if (EQ (pointer
, intern ("hourglass")))
27319 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
27320 else if (EQ (pointer
, Qmodeline
))
27321 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
27323 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27326 if (cursor
!= No_Cursor
)
27327 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
27330 #endif /* HAVE_WINDOW_SYSTEM */
27332 /* Take proper action when mouse has moved to the mode or header line
27333 or marginal area AREA of window W, x-position X and y-position Y.
27334 X is relative to the start of the text display area of W, so the
27335 width of bitmap areas and scroll bars must be subtracted to get a
27336 position relative to the start of the mode line. */
27339 note_mode_line_or_margin_highlight (Lisp_Object window
, int x
, int y
,
27340 enum window_part area
)
27342 struct window
*w
= XWINDOW (window
);
27343 struct frame
*f
= XFRAME (w
->frame
);
27344 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27345 #ifdef HAVE_WINDOW_SYSTEM
27346 Display_Info
*dpyinfo
;
27348 Cursor cursor
= No_Cursor
;
27349 Lisp_Object pointer
= Qnil
;
27350 int dx
, dy
, width
, height
;
27352 Lisp_Object string
, object
= Qnil
;
27353 Lisp_Object pos
IF_LINT (= Qnil
), help
;
27355 Lisp_Object mouse_face
;
27356 int original_x_pixel
= x
;
27357 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
27358 struct glyph_row
*row
IF_LINT (= 0);
27360 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
27365 /* Kludge alert: mode_line_string takes X/Y in pixels, but
27366 returns them in row/column units! */
27367 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
27368 &object
, &dx
, &dy
, &width
, &height
);
27370 row
= (area
== ON_MODE_LINE
27371 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
27372 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
27374 /* Find the glyph under the mouse pointer. */
27375 if (row
->mode_line_p
&& row
->enabled_p
)
27377 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
27378 end
= glyph
+ row
->used
[TEXT_AREA
];
27380 for (x0
= original_x_pixel
;
27381 glyph
< end
&& x0
>= glyph
->pixel_width
;
27383 x0
-= glyph
->pixel_width
;
27391 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
27392 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
27393 returns them in row/column units! */
27394 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
27395 &object
, &dx
, &dy
, &width
, &height
);
27400 #ifdef HAVE_WINDOW_SYSTEM
27401 if (IMAGEP (object
))
27403 Lisp_Object image_map
, hotspot
;
27404 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
27406 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
27408 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
27412 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
27413 If so, we could look for mouse-enter, mouse-leave
27414 properties in PLIST (and do something...). */
27415 hotspot
= XCDR (hotspot
);
27416 if (CONSP (hotspot
)
27417 && (plist
= XCAR (hotspot
), CONSP (plist
)))
27419 pointer
= Fplist_get (plist
, Qpointer
);
27420 if (NILP (pointer
))
27422 help
= Fplist_get (plist
, Qhelp_echo
);
27425 help_echo_string
= help
;
27426 XSETWINDOW (help_echo_window
, w
);
27427 help_echo_object
= w
->buffer
;
27428 help_echo_pos
= charpos
;
27432 if (NILP (pointer
))
27433 pointer
= Fplist_get (XCDR (object
), QCpointer
);
27435 #endif /* HAVE_WINDOW_SYSTEM */
27437 if (STRINGP (string
))
27438 pos
= make_number (charpos
);
27440 /* Set the help text and mouse pointer. If the mouse is on a part
27441 of the mode line without any text (e.g. past the right edge of
27442 the mode line text), use the default help text and pointer. */
27443 if (STRINGP (string
) || area
== ON_MODE_LINE
)
27445 /* Arrange to display the help by setting the global variables
27446 help_echo_string, help_echo_object, and help_echo_pos. */
27449 if (STRINGP (string
))
27450 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
27454 help_echo_string
= help
;
27455 XSETWINDOW (help_echo_window
, w
);
27456 help_echo_object
= string
;
27457 help_echo_pos
= charpos
;
27459 else if (area
== ON_MODE_LINE
)
27461 Lisp_Object default_help
27462 = buffer_local_value_1 (Qmode_line_default_help_echo
,
27465 if (STRINGP (default_help
))
27467 help_echo_string
= default_help
;
27468 XSETWINDOW (help_echo_window
, w
);
27469 help_echo_object
= Qnil
;
27470 help_echo_pos
= -1;
27475 #ifdef HAVE_WINDOW_SYSTEM
27476 /* Change the mouse pointer according to what is under it. */
27477 if (FRAME_WINDOW_P (f
))
27479 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
27480 if (STRINGP (string
))
27482 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27484 if (NILP (pointer
))
27485 pointer
= Fget_text_property (pos
, Qpointer
, string
);
27487 /* Change the mouse pointer according to what is under X/Y. */
27489 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
27492 map
= Fget_text_property (pos
, Qlocal_map
, string
);
27493 if (!KEYMAPP (map
))
27494 map
= Fget_text_property (pos
, Qkeymap
, string
);
27495 if (!KEYMAPP (map
))
27496 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
27500 /* Default mode-line pointer. */
27501 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
27506 /* Change the mouse face according to what is under X/Y. */
27507 if (STRINGP (string
))
27509 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
27510 if (!NILP (mouse_face
)
27511 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
27516 struct glyph
* tmp_glyph
;
27520 int total_pixel_width
;
27521 ptrdiff_t begpos
, endpos
, ignore
;
27525 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
27526 Qmouse_face
, string
, Qnil
);
27532 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
27534 endpos
= SCHARS (string
);
27538 /* Calculate the glyph position GPOS of GLYPH in the
27539 displayed string, relative to the beginning of the
27540 highlighted part of the string.
27542 Note: GPOS is different from CHARPOS. CHARPOS is the
27543 position of GLYPH in the internal string object. A mode
27544 line string format has structures which are converted to
27545 a flattened string by the Emacs Lisp interpreter. The
27546 internal string is an element of those structures. The
27547 displayed string is the flattened string. */
27548 tmp_glyph
= row_start_glyph
;
27549 while (tmp_glyph
< glyph
27550 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
27551 && begpos
<= tmp_glyph
->charpos
27552 && tmp_glyph
->charpos
< endpos
)))
27554 gpos
= glyph
- tmp_glyph
;
27556 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
27557 the highlighted part of the displayed string to which
27558 GLYPH belongs. Note: GSEQ_LENGTH is different from
27559 SCHARS (STRING), because the latter returns the length of
27560 the internal string. */
27561 for (tmp_glyph
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
27563 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
27564 && begpos
<= tmp_glyph
->charpos
27565 && tmp_glyph
->charpos
< endpos
));
27568 gseq_length
= gpos
+ (tmp_glyph
- glyph
) + 1;
27570 /* Calculate the total pixel width of all the glyphs between
27571 the beginning of the highlighted area and GLYPH. */
27572 total_pixel_width
= 0;
27573 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
27574 total_pixel_width
+= tmp_glyph
->pixel_width
;
27576 /* Pre calculation of re-rendering position. Note: X is in
27577 column units here, after the call to mode_line_string or
27578 marginal_area_string. */
27580 vpos
= (area
== ON_MODE_LINE
27581 ? (w
->current_matrix
)->nrows
- 1
27584 /* If GLYPH's position is included in the region that is
27585 already drawn in mouse face, we have nothing to do. */
27586 if ( EQ (window
, hlinfo
->mouse_face_window
)
27587 && (!row
->reversed_p
27588 ? (hlinfo
->mouse_face_beg_col
<= hpos
27589 && hpos
< hlinfo
->mouse_face_end_col
)
27590 /* In R2L rows we swap BEG and END, see below. */
27591 : (hlinfo
->mouse_face_end_col
<= hpos
27592 && hpos
< hlinfo
->mouse_face_beg_col
))
27593 && hlinfo
->mouse_face_beg_row
== vpos
)
27596 if (clear_mouse_face (hlinfo
))
27597 cursor
= No_Cursor
;
27599 if (!row
->reversed_p
)
27601 hlinfo
->mouse_face_beg_col
= hpos
;
27602 hlinfo
->mouse_face_beg_x
= original_x_pixel
27603 - (total_pixel_width
+ dx
);
27604 hlinfo
->mouse_face_end_col
= hpos
+ gseq_length
;
27605 hlinfo
->mouse_face_end_x
= 0;
27609 /* In R2L rows, show_mouse_face expects BEG and END
27610 coordinates to be swapped. */
27611 hlinfo
->mouse_face_end_col
= hpos
;
27612 hlinfo
->mouse_face_end_x
= original_x_pixel
27613 - (total_pixel_width
+ dx
);
27614 hlinfo
->mouse_face_beg_col
= hpos
+ gseq_length
;
27615 hlinfo
->mouse_face_beg_x
= 0;
27618 hlinfo
->mouse_face_beg_row
= vpos
;
27619 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_beg_row
;
27620 hlinfo
->mouse_face_beg_y
= 0;
27621 hlinfo
->mouse_face_end_y
= 0;
27622 hlinfo
->mouse_face_past_end
= 0;
27623 hlinfo
->mouse_face_window
= window
;
27625 hlinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
27631 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
27633 if (NILP (pointer
))
27636 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
27637 clear_mouse_face (hlinfo
);
27639 #ifdef HAVE_WINDOW_SYSTEM
27640 if (FRAME_WINDOW_P (f
))
27641 define_frame_cursor1 (f
, cursor
, pointer
);
27647 Take proper action when the mouse has moved to position X, Y on
27648 frame F as regards highlighting characters that have mouse-face
27649 properties. Also de-highlighting chars where the mouse was before.
27650 X and Y can be negative or out of range. */
27653 note_mouse_highlight (struct frame
*f
, int x
, int y
)
27655 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27656 enum window_part part
= ON_NOTHING
;
27657 Lisp_Object window
;
27659 Cursor cursor
= No_Cursor
;
27660 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
27663 /* When a menu is active, don't highlight because this looks odd. */
27664 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
27665 if (popup_activated ())
27669 if (NILP (Vmouse_highlight
)
27670 || !f
->glyphs_initialized_p
27671 || f
->pointer_invisible
)
27674 hlinfo
->mouse_face_mouse_x
= x
;
27675 hlinfo
->mouse_face_mouse_y
= y
;
27676 hlinfo
->mouse_face_mouse_frame
= f
;
27678 if (hlinfo
->mouse_face_defer
)
27681 if (gc_in_progress
)
27683 hlinfo
->mouse_face_deferred_gc
= 1;
27687 /* Which window is that in? */
27688 window
= window_from_coordinates (f
, x
, y
, &part
, 1);
27690 /* If displaying active text in another window, clear that. */
27691 if (! EQ (window
, hlinfo
->mouse_face_window
)
27692 /* Also clear if we move out of text area in same window. */
27693 || (!NILP (hlinfo
->mouse_face_window
)
27696 && part
!= ON_MODE_LINE
27697 && part
!= ON_HEADER_LINE
))
27698 clear_mouse_face (hlinfo
);
27700 /* Not on a window -> return. */
27701 if (!WINDOWP (window
))
27704 /* Reset help_echo_string. It will get recomputed below. */
27705 help_echo_string
= Qnil
;
27707 /* Convert to window-relative pixel coordinates. */
27708 w
= XWINDOW (window
);
27709 frame_to_window_pixel_xy (w
, &x
, &y
);
27711 #ifdef HAVE_WINDOW_SYSTEM
27712 /* Handle tool-bar window differently since it doesn't display a
27714 if (EQ (window
, f
->tool_bar_window
))
27716 note_tool_bar_highlight (f
, x
, y
);
27721 /* Mouse is on the mode, header line or margin? */
27722 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
27723 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
27725 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
27729 #ifdef HAVE_WINDOW_SYSTEM
27730 if (part
== ON_VERTICAL_BORDER
)
27732 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
27733 help_echo_string
= build_string ("drag-mouse-1: resize");
27735 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
27736 || part
== ON_SCROLL_BAR
)
27737 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27739 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
27742 /* Are we in a window whose display is up to date?
27743 And verify the buffer's text has not changed. */
27744 b
= XBUFFER (w
->buffer
);
27745 if (part
== ON_TEXT
27746 && EQ (w
->window_end_valid
, w
->buffer
)
27747 && w
->last_modified
== BUF_MODIFF (b
)
27748 && w
->last_overlay_modified
== BUF_OVERLAY_MODIFF (b
))
27750 int hpos
, vpos
, dx
, dy
, area
= LAST_AREA
;
27752 struct glyph
*glyph
;
27753 Lisp_Object object
;
27754 Lisp_Object mouse_face
= Qnil
, position
;
27755 Lisp_Object
*overlay_vec
= NULL
;
27756 ptrdiff_t i
, noverlays
;
27757 struct buffer
*obuf
;
27758 ptrdiff_t obegv
, ozv
;
27761 /* Find the glyph under X/Y. */
27762 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
27764 #ifdef HAVE_WINDOW_SYSTEM
27765 /* Look for :pointer property on image. */
27766 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
27768 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
27769 if (img
!= NULL
&& IMAGEP (img
->spec
))
27771 Lisp_Object image_map
, hotspot
;
27772 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
27774 && (hotspot
= find_hot_spot (image_map
,
27775 glyph
->slice
.img
.x
+ dx
,
27776 glyph
->slice
.img
.y
+ dy
),
27778 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
27782 /* Could check XCAR (hotspot) to see if we enter/leave
27784 If so, we could look for mouse-enter, mouse-leave
27785 properties in PLIST (and do something...). */
27786 hotspot
= XCDR (hotspot
);
27787 if (CONSP (hotspot
)
27788 && (plist
= XCAR (hotspot
), CONSP (plist
)))
27790 pointer
= Fplist_get (plist
, Qpointer
);
27791 if (NILP (pointer
))
27793 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
27794 if (!NILP (help_echo_string
))
27796 help_echo_window
= window
;
27797 help_echo_object
= glyph
->object
;
27798 help_echo_pos
= glyph
->charpos
;
27802 if (NILP (pointer
))
27803 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
27806 #endif /* HAVE_WINDOW_SYSTEM */
27808 /* Clear mouse face if X/Y not over text. */
27810 || area
!= TEXT_AREA
27811 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
27812 /* Glyph's OBJECT is an integer for glyphs inserted by the
27813 display engine for its internal purposes, like truncation
27814 and continuation glyphs and blanks beyond the end of
27815 line's text on text terminals. If we are over such a
27816 glyph, we are not over any text. */
27817 || INTEGERP (glyph
->object
)
27818 /* R2L rows have a stretch glyph at their front, which
27819 stands for no text, whereas L2R rows have no glyphs at
27820 all beyond the end of text. Treat such stretch glyphs
27821 like we do with NULL glyphs in L2R rows. */
27822 || (MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
27823 && glyph
== MATRIX_ROW (w
->current_matrix
, vpos
)->glyphs
[TEXT_AREA
]
27824 && glyph
->type
== STRETCH_GLYPH
27825 && glyph
->avoid_cursor_p
))
27827 if (clear_mouse_face (hlinfo
))
27828 cursor
= No_Cursor
;
27829 #ifdef HAVE_WINDOW_SYSTEM
27830 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
27832 if (area
!= TEXT_AREA
)
27833 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27835 pointer
= Vvoid_text_area_pointer
;
27841 pos
= glyph
->charpos
;
27842 object
= glyph
->object
;
27843 if (!STRINGP (object
) && !BUFFERP (object
))
27846 /* If we get an out-of-range value, return now; avoid an error. */
27847 if (BUFFERP (object
) && pos
> BUF_Z (b
))
27850 /* Make the window's buffer temporarily current for
27851 overlays_at and compute_char_face. */
27852 obuf
= current_buffer
;
27853 current_buffer
= b
;
27859 /* Is this char mouse-active or does it have help-echo? */
27860 position
= make_number (pos
);
27862 if (BUFFERP (object
))
27864 /* Put all the overlays we want in a vector in overlay_vec. */
27865 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
27866 /* Sort overlays into increasing priority order. */
27867 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
27872 same_region
= coords_in_mouse_face_p (w
, hpos
, vpos
);
27875 cursor
= No_Cursor
;
27877 /* Check mouse-face highlighting. */
27879 /* If there exists an overlay with mouse-face overlapping
27880 the one we are currently highlighting, we have to
27881 check if we enter the overlapping overlay, and then
27882 highlight only that. */
27883 || (OVERLAYP (hlinfo
->mouse_face_overlay
)
27884 && mouse_face_overlay_overlaps (hlinfo
->mouse_face_overlay
)))
27886 /* Find the highest priority overlay with a mouse-face. */
27887 Lisp_Object overlay
= Qnil
;
27888 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
27890 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
27891 if (!NILP (mouse_face
))
27892 overlay
= overlay_vec
[i
];
27895 /* If we're highlighting the same overlay as before, there's
27896 no need to do that again. */
27897 if (!NILP (overlay
) && EQ (overlay
, hlinfo
->mouse_face_overlay
))
27898 goto check_help_echo
;
27899 hlinfo
->mouse_face_overlay
= overlay
;
27901 /* Clear the display of the old active region, if any. */
27902 if (clear_mouse_face (hlinfo
))
27903 cursor
= No_Cursor
;
27905 /* If no overlay applies, get a text property. */
27906 if (NILP (overlay
))
27907 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
27909 /* Next, compute the bounds of the mouse highlighting and
27911 if (!NILP (mouse_face
) && STRINGP (object
))
27913 /* The mouse-highlighting comes from a display string
27914 with a mouse-face. */
27918 s
= Fprevious_single_property_change
27919 (make_number (pos
+ 1), Qmouse_face
, object
, Qnil
);
27920 e
= Fnext_single_property_change
27921 (position
, Qmouse_face
, object
, Qnil
);
27923 s
= make_number (0);
27925 e
= make_number (SCHARS (object
) - 1);
27926 mouse_face_from_string_pos (w
, hlinfo
, object
,
27927 XINT (s
), XINT (e
));
27928 hlinfo
->mouse_face_past_end
= 0;
27929 hlinfo
->mouse_face_window
= window
;
27930 hlinfo
->mouse_face_face_id
27931 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
27932 glyph
->face_id
, 1);
27933 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
27934 cursor
= No_Cursor
;
27938 /* The mouse-highlighting, if any, comes from an overlay
27939 or text property in the buffer. */
27940 Lisp_Object buffer
IF_LINT (= Qnil
);
27941 Lisp_Object disp_string
IF_LINT (= Qnil
);
27943 if (STRINGP (object
))
27945 /* If we are on a display string with no mouse-face,
27946 check if the text under it has one. */
27947 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
27948 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
27949 pos
= string_buffer_position (object
, start
);
27952 mouse_face
= get_char_property_and_overlay
27953 (make_number (pos
), Qmouse_face
, w
->buffer
, &overlay
);
27954 buffer
= w
->buffer
;
27955 disp_string
= object
;
27961 disp_string
= Qnil
;
27964 if (!NILP (mouse_face
))
27966 Lisp_Object before
, after
;
27967 Lisp_Object before_string
, after_string
;
27968 /* To correctly find the limits of mouse highlight
27969 in a bidi-reordered buffer, we must not use the
27970 optimization of limiting the search in
27971 previous-single-property-change and
27972 next-single-property-change, because
27973 rows_from_pos_range needs the real start and end
27974 positions to DTRT in this case. That's because
27975 the first row visible in a window does not
27976 necessarily display the character whose position
27977 is the smallest. */
27979 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
27980 ? Fmarker_position (w
->start
)
27983 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
27984 ? make_number (BUF_Z (XBUFFER (buffer
))
27985 - XFASTINT (w
->window_end_pos
))
27988 if (NILP (overlay
))
27990 /* Handle the text property case. */
27991 before
= Fprevious_single_property_change
27992 (make_number (pos
+ 1), Qmouse_face
, buffer
, lim1
);
27993 after
= Fnext_single_property_change
27994 (make_number (pos
), Qmouse_face
, buffer
, lim2
);
27995 before_string
= after_string
= Qnil
;
27999 /* Handle the overlay case. */
28000 before
= Foverlay_start (overlay
);
28001 after
= Foverlay_end (overlay
);
28002 before_string
= Foverlay_get (overlay
, Qbefore_string
);
28003 after_string
= Foverlay_get (overlay
, Qafter_string
);
28005 if (!STRINGP (before_string
)) before_string
= Qnil
;
28006 if (!STRINGP (after_string
)) after_string
= Qnil
;
28009 mouse_face_from_buffer_pos (window
, hlinfo
, pos
,
28012 : XFASTINT (before
),
28014 ? BUF_Z (XBUFFER (buffer
))
28015 : XFASTINT (after
),
28016 before_string
, after_string
,
28018 cursor
= No_Cursor
;
28025 /* Look for a `help-echo' property. */
28026 if (NILP (help_echo_string
)) {
28027 Lisp_Object help
, overlay
;
28029 /* Check overlays first. */
28030 help
= overlay
= Qnil
;
28031 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
28033 overlay
= overlay_vec
[i
];
28034 help
= Foverlay_get (overlay
, Qhelp_echo
);
28039 help_echo_string
= help
;
28040 help_echo_window
= window
;
28041 help_echo_object
= overlay
;
28042 help_echo_pos
= pos
;
28046 Lisp_Object obj
= glyph
->object
;
28047 ptrdiff_t charpos
= glyph
->charpos
;
28049 /* Try text properties. */
28052 && charpos
< SCHARS (obj
))
28054 help
= Fget_text_property (make_number (charpos
),
28058 /* If the string itself doesn't specify a help-echo,
28059 see if the buffer text ``under'' it does. */
28060 struct glyph_row
*r
28061 = MATRIX_ROW (w
->current_matrix
, vpos
);
28062 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
28063 ptrdiff_t p
= string_buffer_position (obj
, start
);
28066 help
= Fget_char_property (make_number (p
),
28067 Qhelp_echo
, w
->buffer
);
28076 else if (BUFFERP (obj
)
28079 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
28084 help_echo_string
= help
;
28085 help_echo_window
= window
;
28086 help_echo_object
= obj
;
28087 help_echo_pos
= charpos
;
28092 #ifdef HAVE_WINDOW_SYSTEM
28093 /* Look for a `pointer' property. */
28094 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
28096 /* Check overlays first. */
28097 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
28098 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
28100 if (NILP (pointer
))
28102 Lisp_Object obj
= glyph
->object
;
28103 ptrdiff_t charpos
= glyph
->charpos
;
28105 /* Try text properties. */
28108 && charpos
< SCHARS (obj
))
28110 pointer
= Fget_text_property (make_number (charpos
),
28112 if (NILP (pointer
))
28114 /* If the string itself doesn't specify a pointer,
28115 see if the buffer text ``under'' it does. */
28116 struct glyph_row
*r
28117 = MATRIX_ROW (w
->current_matrix
, vpos
);
28118 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
28119 ptrdiff_t p
= string_buffer_position (obj
, start
);
28121 pointer
= Fget_char_property (make_number (p
),
28122 Qpointer
, w
->buffer
);
28125 else if (BUFFERP (obj
)
28128 pointer
= Fget_text_property (make_number (charpos
),
28132 #endif /* HAVE_WINDOW_SYSTEM */
28136 current_buffer
= obuf
;
28141 #ifdef HAVE_WINDOW_SYSTEM
28142 if (FRAME_WINDOW_P (f
))
28143 define_frame_cursor1 (f
, cursor
, pointer
);
28145 /* This is here to prevent a compiler error, about "label at end of
28146 compound statement". */
28153 Clear any mouse-face on window W. This function is part of the
28154 redisplay interface, and is called from try_window_id and similar
28155 functions to ensure the mouse-highlight is off. */
28158 x_clear_window_mouse_face (struct window
*w
)
28160 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
28161 Lisp_Object window
;
28164 XSETWINDOW (window
, w
);
28165 if (EQ (window
, hlinfo
->mouse_face_window
))
28166 clear_mouse_face (hlinfo
);
28172 Just discard the mouse face information for frame F, if any.
28173 This is used when the size of F is changed. */
28176 cancel_mouse_face (struct frame
*f
)
28178 Lisp_Object window
;
28179 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28181 window
= hlinfo
->mouse_face_window
;
28182 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
28184 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
28185 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
28186 hlinfo
->mouse_face_window
= Qnil
;
28192 /***********************************************************************
28194 ***********************************************************************/
28196 #ifdef HAVE_WINDOW_SYSTEM
28198 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
28199 which intersects rectangle R. R is in window-relative coordinates. */
28202 expose_area (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
,
28203 enum glyph_row_area area
)
28205 struct glyph
*first
= row
->glyphs
[area
];
28206 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
28207 struct glyph
*last
;
28208 int first_x
, start_x
, x
;
28210 if (area
== TEXT_AREA
&& row
->fill_line_p
)
28211 /* If row extends face to end of line write the whole line. */
28212 draw_glyphs (w
, 0, row
, area
,
28213 0, row
->used
[area
],
28214 DRAW_NORMAL_TEXT
, 0);
28217 /* Set START_X to the window-relative start position for drawing glyphs of
28218 AREA. The first glyph of the text area can be partially visible.
28219 The first glyphs of other areas cannot. */
28220 start_x
= window_box_left_offset (w
, area
);
28222 if (area
== TEXT_AREA
)
28225 /* Find the first glyph that must be redrawn. */
28227 && x
+ first
->pixel_width
< r
->x
)
28229 x
+= first
->pixel_width
;
28233 /* Find the last one. */
28237 && x
< r
->x
+ r
->width
)
28239 x
+= last
->pixel_width
;
28245 draw_glyphs (w
, first_x
- start_x
, row
, area
,
28246 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
28247 DRAW_NORMAL_TEXT
, 0);
28252 /* Redraw the parts of the glyph row ROW on window W intersecting
28253 rectangle R. R is in window-relative coordinates. Value is
28254 non-zero if mouse-face was overwritten. */
28257 expose_line (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
)
28259 eassert (row
->enabled_p
);
28261 if (row
->mode_line_p
|| w
->pseudo_window_p
)
28262 draw_glyphs (w
, 0, row
, TEXT_AREA
,
28263 0, row
->used
[TEXT_AREA
],
28264 DRAW_NORMAL_TEXT
, 0);
28267 if (row
->used
[LEFT_MARGIN_AREA
])
28268 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
28269 if (row
->used
[TEXT_AREA
])
28270 expose_area (w
, row
, r
, TEXT_AREA
);
28271 if (row
->used
[RIGHT_MARGIN_AREA
])
28272 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
28273 draw_row_fringe_bitmaps (w
, row
);
28276 return row
->mouse_face_p
;
28280 /* Redraw those parts of glyphs rows during expose event handling that
28281 overlap other rows. Redrawing of an exposed line writes over parts
28282 of lines overlapping that exposed line; this function fixes that.
28284 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
28285 row in W's current matrix that is exposed and overlaps other rows.
28286 LAST_OVERLAPPING_ROW is the last such row. */
28289 expose_overlaps (struct window
*w
,
28290 struct glyph_row
*first_overlapping_row
,
28291 struct glyph_row
*last_overlapping_row
,
28294 struct glyph_row
*row
;
28296 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
28297 if (row
->overlapping_p
)
28299 eassert (row
->enabled_p
&& !row
->mode_line_p
);
28302 if (row
->used
[LEFT_MARGIN_AREA
])
28303 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
28305 if (row
->used
[TEXT_AREA
])
28306 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
28308 if (row
->used
[RIGHT_MARGIN_AREA
])
28309 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
28315 /* Return non-zero if W's cursor intersects rectangle R. */
28318 phys_cursor_in_rect_p (struct window
*w
, XRectangle
*r
)
28320 XRectangle cr
, result
;
28321 struct glyph
*cursor_glyph
;
28322 struct glyph_row
*row
;
28324 if (w
->phys_cursor
.vpos
>= 0
28325 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
28326 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
28328 && row
->cursor_in_fringe_p
)
28330 /* Cursor is in the fringe. */
28331 cr
.x
= window_box_right_offset (w
,
28332 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
28333 ? RIGHT_MARGIN_AREA
28336 cr
.width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
28337 cr
.height
= row
->height
;
28338 return x_intersect_rectangles (&cr
, r
, &result
);
28341 cursor_glyph
= get_phys_cursor_glyph (w
);
28344 /* r is relative to W's box, but w->phys_cursor.x is relative
28345 to left edge of W's TEXT area. Adjust it. */
28346 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
28347 cr
.y
= w
->phys_cursor
.y
;
28348 cr
.width
= cursor_glyph
->pixel_width
;
28349 cr
.height
= w
->phys_cursor_height
;
28350 /* ++KFS: W32 version used W32-specific IntersectRect here, but
28351 I assume the effect is the same -- and this is portable. */
28352 return x_intersect_rectangles (&cr
, r
, &result
);
28354 /* If we don't understand the format, pretend we're not in the hot-spot. */
28360 Draw a vertical window border to the right of window W if W doesn't
28361 have vertical scroll bars. */
28364 x_draw_vertical_border (struct window
*w
)
28366 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
28368 /* We could do better, if we knew what type of scroll-bar the adjacent
28369 windows (on either side) have... But we don't :-(
28370 However, I think this works ok. ++KFS 2003-04-25 */
28372 /* Redraw borders between horizontally adjacent windows. Don't
28373 do it for frames with vertical scroll bars because either the
28374 right scroll bar of a window, or the left scroll bar of its
28375 neighbor will suffice as a border. */
28376 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w
->frame
)))
28379 if (!WINDOW_RIGHTMOST_P (w
)
28380 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
28382 int x0
, x1
, y0
, y1
;
28384 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
28387 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
28390 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
28392 else if (!WINDOW_LEFTMOST_P (w
)
28393 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
28395 int x0
, x1
, y0
, y1
;
28397 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
28400 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
28403 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
28408 /* Redraw the part of window W intersection rectangle FR. Pixel
28409 coordinates in FR are frame-relative. Call this function with
28410 input blocked. Value is non-zero if the exposure overwrites
28414 expose_window (struct window
*w
, XRectangle
*fr
)
28416 struct frame
*f
= XFRAME (w
->frame
);
28418 int mouse_face_overwritten_p
= 0;
28420 /* If window is not yet fully initialized, do nothing. This can
28421 happen when toolkit scroll bars are used and a window is split.
28422 Reconfiguring the scroll bar will generate an expose for a newly
28424 if (w
->current_matrix
== NULL
)
28427 /* When we're currently updating the window, display and current
28428 matrix usually don't agree. Arrange for a thorough display
28430 if (w
== updated_window
)
28432 SET_FRAME_GARBAGED (f
);
28436 /* Frame-relative pixel rectangle of W. */
28437 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
28438 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
28439 wr
.width
= WINDOW_TOTAL_WIDTH (w
);
28440 wr
.height
= WINDOW_TOTAL_HEIGHT (w
);
28442 if (x_intersect_rectangles (fr
, &wr
, &r
))
28444 int yb
= window_text_bottom_y (w
);
28445 struct glyph_row
*row
;
28446 int cursor_cleared_p
, phys_cursor_on_p
;
28447 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
28449 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
28450 r
.x
, r
.y
, r
.width
, r
.height
));
28452 /* Convert to window coordinates. */
28453 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
28454 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
28456 /* Turn off the cursor. */
28457 if (!w
->pseudo_window_p
28458 && phys_cursor_in_rect_p (w
, &r
))
28460 x_clear_cursor (w
);
28461 cursor_cleared_p
= 1;
28464 cursor_cleared_p
= 0;
28466 /* If the row containing the cursor extends face to end of line,
28467 then expose_area might overwrite the cursor outside the
28468 rectangle and thus notice_overwritten_cursor might clear
28469 w->phys_cursor_on_p. We remember the original value and
28470 check later if it is changed. */
28471 phys_cursor_on_p
= w
->phys_cursor_on_p
;
28473 /* Update lines intersecting rectangle R. */
28474 first_overlapping_row
= last_overlapping_row
= NULL
;
28475 for (row
= w
->current_matrix
->rows
;
28480 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
28482 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
28483 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
28484 || (r
.y
>= y0
&& r
.y
< y1
)
28485 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
28487 /* A header line may be overlapping, but there is no need
28488 to fix overlapping areas for them. KFS 2005-02-12 */
28489 if (row
->overlapping_p
&& !row
->mode_line_p
)
28491 if (first_overlapping_row
== NULL
)
28492 first_overlapping_row
= row
;
28493 last_overlapping_row
= row
;
28497 if (expose_line (w
, row
, &r
))
28498 mouse_face_overwritten_p
= 1;
28501 else if (row
->overlapping_p
)
28503 /* We must redraw a row overlapping the exposed area. */
28505 ? y0
+ row
->phys_height
> r
.y
28506 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
28508 if (first_overlapping_row
== NULL
)
28509 first_overlapping_row
= row
;
28510 last_overlapping_row
= row
;
28518 /* Display the mode line if there is one. */
28519 if (WINDOW_WANTS_MODELINE_P (w
)
28520 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
28522 && row
->y
< r
.y
+ r
.height
)
28524 if (expose_line (w
, row
, &r
))
28525 mouse_face_overwritten_p
= 1;
28528 if (!w
->pseudo_window_p
)
28530 /* Fix the display of overlapping rows. */
28531 if (first_overlapping_row
)
28532 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
28535 /* Draw border between windows. */
28536 x_draw_vertical_border (w
);
28538 /* Turn the cursor on again. */
28539 if (cursor_cleared_p
28540 || (phys_cursor_on_p
&& !w
->phys_cursor_on_p
))
28541 update_window_cursor (w
, 1);
28545 return mouse_face_overwritten_p
;
28550 /* Redraw (parts) of all windows in the window tree rooted at W that
28551 intersect R. R contains frame pixel coordinates. Value is
28552 non-zero if the exposure overwrites mouse-face. */
28555 expose_window_tree (struct window
*w
, XRectangle
*r
)
28557 struct frame
*f
= XFRAME (w
->frame
);
28558 int mouse_face_overwritten_p
= 0;
28560 while (w
&& !FRAME_GARBAGED_P (f
))
28562 if (!NILP (w
->hchild
))
28563 mouse_face_overwritten_p
28564 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
28565 else if (!NILP (w
->vchild
))
28566 mouse_face_overwritten_p
28567 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
28569 mouse_face_overwritten_p
|= expose_window (w
, r
);
28571 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
28574 return mouse_face_overwritten_p
;
28579 Redisplay an exposed area of frame F. X and Y are the upper-left
28580 corner of the exposed rectangle. W and H are width and height of
28581 the exposed area. All are pixel values. W or H zero means redraw
28582 the entire frame. */
28585 expose_frame (struct frame
*f
, int x
, int y
, int w
, int h
)
28588 int mouse_face_overwritten_p
= 0;
28590 TRACE ((stderr
, "expose_frame "));
28592 /* No need to redraw if frame will be redrawn soon. */
28593 if (FRAME_GARBAGED_P (f
))
28595 TRACE ((stderr
, " garbaged\n"));
28599 /* If basic faces haven't been realized yet, there is no point in
28600 trying to redraw anything. This can happen when we get an expose
28601 event while Emacs is starting, e.g. by moving another window. */
28602 if (FRAME_FACE_CACHE (f
) == NULL
28603 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
28605 TRACE ((stderr
, " no faces\n"));
28609 if (w
== 0 || h
== 0)
28612 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
28613 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
28623 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
28624 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
28626 if (WINDOWP (f
->tool_bar_window
))
28627 mouse_face_overwritten_p
28628 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
28630 #ifdef HAVE_X_WINDOWS
28632 #ifndef USE_X_TOOLKIT
28633 if (WINDOWP (f
->menu_bar_window
))
28634 mouse_face_overwritten_p
28635 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
28636 #endif /* not USE_X_TOOLKIT */
28640 /* Some window managers support a focus-follows-mouse style with
28641 delayed raising of frames. Imagine a partially obscured frame,
28642 and moving the mouse into partially obscured mouse-face on that
28643 frame. The visible part of the mouse-face will be highlighted,
28644 then the WM raises the obscured frame. With at least one WM, KDE
28645 2.1, Emacs is not getting any event for the raising of the frame
28646 (even tried with SubstructureRedirectMask), only Expose events.
28647 These expose events will draw text normally, i.e. not
28648 highlighted. Which means we must redo the highlight here.
28649 Subsume it under ``we love X''. --gerd 2001-08-15 */
28650 /* Included in Windows version because Windows most likely does not
28651 do the right thing if any third party tool offers
28652 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
28653 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
28655 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28656 if (f
== hlinfo
->mouse_face_mouse_frame
)
28658 int mouse_x
= hlinfo
->mouse_face_mouse_x
;
28659 int mouse_y
= hlinfo
->mouse_face_mouse_y
;
28660 clear_mouse_face (hlinfo
);
28661 note_mouse_highlight (f
, mouse_x
, mouse_y
);
28668 Determine the intersection of two rectangles R1 and R2. Return
28669 the intersection in *RESULT. Value is non-zero if RESULT is not
28673 x_intersect_rectangles (XRectangle
*r1
, XRectangle
*r2
, XRectangle
*result
)
28675 XRectangle
*left
, *right
;
28676 XRectangle
*upper
, *lower
;
28677 int intersection_p
= 0;
28679 /* Rearrange so that R1 is the left-most rectangle. */
28681 left
= r1
, right
= r2
;
28683 left
= r2
, right
= r1
;
28685 /* X0 of the intersection is right.x0, if this is inside R1,
28686 otherwise there is no intersection. */
28687 if (right
->x
<= left
->x
+ left
->width
)
28689 result
->x
= right
->x
;
28691 /* The right end of the intersection is the minimum of
28692 the right ends of left and right. */
28693 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
28696 /* Same game for Y. */
28698 upper
= r1
, lower
= r2
;
28700 upper
= r2
, lower
= r1
;
28702 /* The upper end of the intersection is lower.y0, if this is inside
28703 of upper. Otherwise, there is no intersection. */
28704 if (lower
->y
<= upper
->y
+ upper
->height
)
28706 result
->y
= lower
->y
;
28708 /* The lower end of the intersection is the minimum of the lower
28709 ends of upper and lower. */
28710 result
->height
= (min (lower
->y
+ lower
->height
,
28711 upper
->y
+ upper
->height
)
28713 intersection_p
= 1;
28717 return intersection_p
;
28720 #endif /* HAVE_WINDOW_SYSTEM */
28723 /***********************************************************************
28725 ***********************************************************************/
28728 syms_of_xdisp (void)
28730 Vwith_echo_area_save_vector
= Qnil
;
28731 staticpro (&Vwith_echo_area_save_vector
);
28733 Vmessage_stack
= Qnil
;
28734 staticpro (&Vmessage_stack
);
28736 DEFSYM (Qinhibit_redisplay
, "inhibit-redisplay");
28737 DEFSYM (Qredisplay_internal
, "redisplay_internal (C function)");
28739 message_dolog_marker1
= Fmake_marker ();
28740 staticpro (&message_dolog_marker1
);
28741 message_dolog_marker2
= Fmake_marker ();
28742 staticpro (&message_dolog_marker2
);
28743 message_dolog_marker3
= Fmake_marker ();
28744 staticpro (&message_dolog_marker3
);
28747 defsubr (&Sdump_frame_glyph_matrix
);
28748 defsubr (&Sdump_glyph_matrix
);
28749 defsubr (&Sdump_glyph_row
);
28750 defsubr (&Sdump_tool_bar_row
);
28751 defsubr (&Strace_redisplay
);
28752 defsubr (&Strace_to_stderr
);
28754 #ifdef HAVE_WINDOW_SYSTEM
28755 defsubr (&Stool_bar_lines_needed
);
28756 defsubr (&Slookup_image_map
);
28758 defsubr (&Sformat_mode_line
);
28759 defsubr (&Sinvisible_p
);
28760 defsubr (&Scurrent_bidi_paragraph_direction
);
28762 DEFSYM (Qmenu_bar_update_hook
, "menu-bar-update-hook");
28763 DEFSYM (Qoverriding_terminal_local_map
, "overriding-terminal-local-map");
28764 DEFSYM (Qoverriding_local_map
, "overriding-local-map");
28765 DEFSYM (Qwindow_scroll_functions
, "window-scroll-functions");
28766 DEFSYM (Qwindow_text_change_functions
, "window-text-change-functions");
28767 DEFSYM (Qredisplay_end_trigger_functions
, "redisplay-end-trigger-functions");
28768 DEFSYM (Qinhibit_point_motion_hooks
, "inhibit-point-motion-hooks");
28769 DEFSYM (Qeval
, "eval");
28770 DEFSYM (QCdata
, ":data");
28771 DEFSYM (Qdisplay
, "display");
28772 DEFSYM (Qspace_width
, "space-width");
28773 DEFSYM (Qraise
, "raise");
28774 DEFSYM (Qslice
, "slice");
28775 DEFSYM (Qspace
, "space");
28776 DEFSYM (Qmargin
, "margin");
28777 DEFSYM (Qpointer
, "pointer");
28778 DEFSYM (Qleft_margin
, "left-margin");
28779 DEFSYM (Qright_margin
, "right-margin");
28780 DEFSYM (Qcenter
, "center");
28781 DEFSYM (Qline_height
, "line-height");
28782 DEFSYM (QCalign_to
, ":align-to");
28783 DEFSYM (QCrelative_width
, ":relative-width");
28784 DEFSYM (QCrelative_height
, ":relative-height");
28785 DEFSYM (QCeval
, ":eval");
28786 DEFSYM (QCpropertize
, ":propertize");
28787 DEFSYM (QCfile
, ":file");
28788 DEFSYM (Qfontified
, "fontified");
28789 DEFSYM (Qfontification_functions
, "fontification-functions");
28790 DEFSYM (Qtrailing_whitespace
, "trailing-whitespace");
28791 DEFSYM (Qescape_glyph
, "escape-glyph");
28792 DEFSYM (Qnobreak_space
, "nobreak-space");
28793 DEFSYM (Qimage
, "image");
28794 DEFSYM (Qtext
, "text");
28795 DEFSYM (Qboth
, "both");
28796 DEFSYM (Qboth_horiz
, "both-horiz");
28797 DEFSYM (Qtext_image_horiz
, "text-image-horiz");
28798 DEFSYM (QCmap
, ":map");
28799 DEFSYM (QCpointer
, ":pointer");
28800 DEFSYM (Qrect
, "rect");
28801 DEFSYM (Qcircle
, "circle");
28802 DEFSYM (Qpoly
, "poly");
28803 DEFSYM (Qmessage_truncate_lines
, "message-truncate-lines");
28804 DEFSYM (Qgrow_only
, "grow-only");
28805 DEFSYM (Qinhibit_menubar_update
, "inhibit-menubar-update");
28806 DEFSYM (Qinhibit_eval_during_redisplay
, "inhibit-eval-during-redisplay");
28807 DEFSYM (Qposition
, "position");
28808 DEFSYM (Qbuffer_position
, "buffer-position");
28809 DEFSYM (Qobject
, "object");
28810 DEFSYM (Qbar
, "bar");
28811 DEFSYM (Qhbar
, "hbar");
28812 DEFSYM (Qbox
, "box");
28813 DEFSYM (Qhollow
, "hollow");
28814 DEFSYM (Qhand
, "hand");
28815 DEFSYM (Qarrow
, "arrow");
28816 DEFSYM (Qinhibit_free_realized_faces
, "inhibit-free-realized-faces");
28818 list_of_error
= Fcons (Fcons (intern_c_string ("error"),
28819 Fcons (intern_c_string ("void-variable"), Qnil
)),
28821 staticpro (&list_of_error
);
28823 DEFSYM (Qlast_arrow_position
, "last-arrow-position");
28824 DEFSYM (Qlast_arrow_string
, "last-arrow-string");
28825 DEFSYM (Qoverlay_arrow_string
, "overlay-arrow-string");
28826 DEFSYM (Qoverlay_arrow_bitmap
, "overlay-arrow-bitmap");
28828 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
28829 staticpro (&echo_buffer
[0]);
28830 staticpro (&echo_buffer
[1]);
28832 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
28833 staticpro (&echo_area_buffer
[0]);
28834 staticpro (&echo_area_buffer
[1]);
28836 Vmessages_buffer_name
= build_pure_c_string ("*Messages*");
28837 staticpro (&Vmessages_buffer_name
);
28839 mode_line_proptrans_alist
= Qnil
;
28840 staticpro (&mode_line_proptrans_alist
);
28841 mode_line_string_list
= Qnil
;
28842 staticpro (&mode_line_string_list
);
28843 mode_line_string_face
= Qnil
;
28844 staticpro (&mode_line_string_face
);
28845 mode_line_string_face_prop
= Qnil
;
28846 staticpro (&mode_line_string_face_prop
);
28847 Vmode_line_unwind_vector
= Qnil
;
28848 staticpro (&Vmode_line_unwind_vector
);
28850 DEFSYM (Qmode_line_default_help_echo
, "mode-line-default-help-echo");
28852 help_echo_string
= Qnil
;
28853 staticpro (&help_echo_string
);
28854 help_echo_object
= Qnil
;
28855 staticpro (&help_echo_object
);
28856 help_echo_window
= Qnil
;
28857 staticpro (&help_echo_window
);
28858 previous_help_echo_string
= Qnil
;
28859 staticpro (&previous_help_echo_string
);
28860 help_echo_pos
= -1;
28862 DEFSYM (Qright_to_left
, "right-to-left");
28863 DEFSYM (Qleft_to_right
, "left-to-right");
28865 #ifdef HAVE_WINDOW_SYSTEM
28866 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p
,
28867 doc
: /* Non-nil means draw block cursor as wide as the glyph under it.
28868 For example, if a block cursor is over a tab, it will be drawn as
28869 wide as that tab on the display. */);
28870 x_stretch_cursor_p
= 0;
28873 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace
,
28874 doc
: /* Non-nil means highlight trailing whitespace.
28875 The face used for trailing whitespace is `trailing-whitespace'. */);
28876 Vshow_trailing_whitespace
= Qnil
;
28878 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display
,
28879 doc
: /* Control highlighting of non-ASCII space and hyphen chars.
28880 If the value is t, Emacs highlights non-ASCII chars which have the
28881 same appearance as an ASCII space or hyphen, using the `nobreak-space'
28882 or `escape-glyph' face respectively.
28884 U+00A0 (no-break space), U+00AD (soft hyphen), U+2010 (hyphen), and
28885 U+2011 (non-breaking hyphen) are affected.
28887 Any other non-nil value means to display these characters as a escape
28888 glyph followed by an ordinary space or hyphen.
28890 A value of nil means no special handling of these characters. */);
28891 Vnobreak_char_display
= Qt
;
28893 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer
,
28894 doc
: /* The pointer shape to show in void text areas.
28895 A value of nil means to show the text pointer. Other options are `arrow',
28896 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
28897 Vvoid_text_area_pointer
= Qarrow
;
28899 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay
,
28900 doc
: /* Non-nil means don't actually do any redisplay.
28901 This is used for internal purposes. */);
28902 Vinhibit_redisplay
= Qnil
;
28904 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string
,
28905 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
28906 Vglobal_mode_string
= Qnil
;
28908 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position
,
28909 doc
: /* Marker for where to display an arrow on top of the buffer text.
28910 This must be the beginning of a line in order to work.
28911 See also `overlay-arrow-string'. */);
28912 Voverlay_arrow_position
= Qnil
;
28914 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string
,
28915 doc
: /* String to display as an arrow in non-window frames.
28916 See also `overlay-arrow-position'. */);
28917 Voverlay_arrow_string
= build_pure_c_string ("=>");
28919 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list
,
28920 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
28921 The symbols on this list are examined during redisplay to determine
28922 where to display overlay arrows. */);
28923 Voverlay_arrow_variable_list
28924 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil
);
28926 DEFVAR_INT ("scroll-step", emacs_scroll_step
,
28927 doc
: /* The number of lines to try scrolling a window by when point moves out.
28928 If that fails to bring point back on frame, point is centered instead.
28929 If this is zero, point is always centered after it moves off frame.
28930 If you want scrolling to always be a line at a time, you should set
28931 `scroll-conservatively' to a large value rather than set this to 1. */);
28933 DEFVAR_INT ("scroll-conservatively", scroll_conservatively
,
28934 doc
: /* Scroll up to this many lines, to bring point back on screen.
28935 If point moves off-screen, redisplay will scroll by up to
28936 `scroll-conservatively' lines in order to bring point just barely
28937 onto the screen again. If that cannot be done, then redisplay
28938 recenters point as usual.
28940 If the value is greater than 100, redisplay will never recenter point,
28941 but will always scroll just enough text to bring point into view, even
28942 if you move far away.
28944 A value of zero means always recenter point if it moves off screen. */);
28945 scroll_conservatively
= 0;
28947 DEFVAR_INT ("scroll-margin", scroll_margin
,
28948 doc
: /* Number of lines of margin at the top and bottom of a window.
28949 Recenter the window whenever point gets within this many lines
28950 of the top or bottom of the window. */);
28953 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch
,
28954 doc
: /* Pixels per inch value for non-window system displays.
28955 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
28956 Vdisplay_pixels_per_inch
= make_float (72.0);
28959 DEFVAR_INT ("debug-end-pos", debug_end_pos
, doc
: /* Don't ask. */);
28962 DEFVAR_LISP ("truncate-partial-width-windows",
28963 Vtruncate_partial_width_windows
,
28964 doc
: /* Non-nil means truncate lines in windows narrower than the frame.
28965 For an integer value, truncate lines in each window narrower than the
28966 full frame width, provided the window width is less than that integer;
28967 otherwise, respect the value of `truncate-lines'.
28969 For any other non-nil value, truncate lines in all windows that do
28970 not span the full frame width.
28972 A value of nil means to respect the value of `truncate-lines'.
28974 If `word-wrap' is enabled, you might want to reduce this. */);
28975 Vtruncate_partial_width_windows
= make_number (50);
28977 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit
,
28978 doc
: /* Maximum buffer size for which line number should be displayed.
28979 If the buffer is bigger than this, the line number does not appear
28980 in the mode line. A value of nil means no limit. */);
28981 Vline_number_display_limit
= Qnil
;
28983 DEFVAR_INT ("line-number-display-limit-width",
28984 line_number_display_limit_width
,
28985 doc
: /* Maximum line width (in characters) for line number display.
28986 If the average length of the lines near point is bigger than this, then the
28987 line number may be omitted from the mode line. */);
28988 line_number_display_limit_width
= 200;
28990 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows
,
28991 doc
: /* Non-nil means highlight region even in nonselected windows. */);
28992 highlight_nonselected_windows
= 0;
28994 DEFVAR_BOOL ("multiple-frames", multiple_frames
,
28995 doc
: /* Non-nil if more than one frame is visible on this display.
28996 Minibuffer-only frames don't count, but iconified frames do.
28997 This variable is not guaranteed to be accurate except while processing
28998 `frame-title-format' and `icon-title-format'. */);
29000 DEFVAR_LISP ("frame-title-format", Vframe_title_format
,
29001 doc
: /* Template for displaying the title bar of visible frames.
29002 \(Assuming the window manager supports this feature.)
29004 This variable has the same structure as `mode-line-format', except that
29005 the %c and %l constructs are ignored. It is used only on frames for
29006 which no explicit name has been set \(see `modify-frame-parameters'). */);
29008 DEFVAR_LISP ("icon-title-format", Vicon_title_format
,
29009 doc
: /* Template for displaying the title bar of an iconified frame.
29010 \(Assuming the window manager supports this feature.)
29011 This variable has the same structure as `mode-line-format' (which see),
29012 and is used only on frames for which no explicit name has been set
29013 \(see `modify-frame-parameters'). */);
29015 = Vframe_title_format
29016 = listn (CONSTYPE_PURE
, 3,
29017 intern_c_string ("multiple-frames"),
29018 build_pure_c_string ("%b"),
29019 listn (CONSTYPE_PURE
, 4,
29020 empty_unibyte_string
,
29021 intern_c_string ("invocation-name"),
29022 build_pure_c_string ("@"),
29023 intern_c_string ("system-name")));
29025 DEFVAR_LISP ("message-log-max", Vmessage_log_max
,
29026 doc
: /* Maximum number of lines to keep in the message log buffer.
29027 If nil, disable message logging. If t, log messages but don't truncate
29028 the buffer when it becomes large. */);
29029 Vmessage_log_max
= make_number (1000);
29031 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions
,
29032 doc
: /* Functions called before redisplay, if window sizes have changed.
29033 The value should be a list of functions that take one argument.
29034 Just before redisplay, for each frame, if any of its windows have changed
29035 size since the last redisplay, or have been split or deleted,
29036 all the functions in the list are called, with the frame as argument. */);
29037 Vwindow_size_change_functions
= Qnil
;
29039 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions
,
29040 doc
: /* List of functions to call before redisplaying a window with scrolling.
29041 Each function is called with two arguments, the window and its new
29042 display-start position. Note that these functions are also called by
29043 `set-window-buffer'. Also note that the value of `window-end' is not
29044 valid when these functions are called.
29046 Warning: Do not use this feature to alter the way the window
29047 is scrolled. It is not designed for that, and such use probably won't
29049 Vwindow_scroll_functions
= Qnil
;
29051 DEFVAR_LISP ("window-text-change-functions",
29052 Vwindow_text_change_functions
,
29053 doc
: /* Functions to call in redisplay when text in the window might change. */);
29054 Vwindow_text_change_functions
= Qnil
;
29056 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions
,
29057 doc
: /* Functions called when redisplay of a window reaches the end trigger.
29058 Each function is called with two arguments, the window and the end trigger value.
29059 See `set-window-redisplay-end-trigger'. */);
29060 Vredisplay_end_trigger_functions
= Qnil
;
29062 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window
,
29063 doc
: /* Non-nil means autoselect window with mouse pointer.
29064 If nil, do not autoselect windows.
29065 A positive number means delay autoselection by that many seconds: a
29066 window is autoselected only after the mouse has remained in that
29067 window for the duration of the delay.
29068 A negative number has a similar effect, but causes windows to be
29069 autoselected only after the mouse has stopped moving. \(Because of
29070 the way Emacs compares mouse events, you will occasionally wait twice
29071 that time before the window gets selected.\)
29072 Any other value means to autoselect window instantaneously when the
29073 mouse pointer enters it.
29075 Autoselection selects the minibuffer only if it is active, and never
29076 unselects the minibuffer if it is active.
29078 When customizing this variable make sure that the actual value of
29079 `focus-follows-mouse' matches the behavior of your window manager. */);
29080 Vmouse_autoselect_window
= Qnil
;
29082 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars
,
29083 doc
: /* Non-nil means automatically resize tool-bars.
29084 This dynamically changes the tool-bar's height to the minimum height
29085 that is needed to make all tool-bar items visible.
29086 If value is `grow-only', the tool-bar's height is only increased
29087 automatically; to decrease the tool-bar height, use \\[recenter]. */);
29088 Vauto_resize_tool_bars
= Qt
;
29090 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p
,
29091 doc
: /* Non-nil means raise tool-bar buttons when the mouse moves over them. */);
29092 auto_raise_tool_bar_buttons_p
= 1;
29094 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p
,
29095 doc
: /* Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
29096 make_cursor_line_fully_visible_p
= 1;
29098 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border
,
29099 doc
: /* Border below tool-bar in pixels.
29100 If an integer, use it as the height of the border.
29101 If it is one of `internal-border-width' or `border-width', use the
29102 value of the corresponding frame parameter.
29103 Otherwise, no border is added below the tool-bar. */);
29104 Vtool_bar_border
= Qinternal_border_width
;
29106 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin
,
29107 doc
: /* Margin around tool-bar buttons in pixels.
29108 If an integer, use that for both horizontal and vertical margins.
29109 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
29110 HORZ specifying the horizontal margin, and VERT specifying the
29111 vertical margin. */);
29112 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
29114 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief
,
29115 doc
: /* Relief thickness of tool-bar buttons. */);
29116 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
29118 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style
,
29119 doc
: /* Tool bar style to use.
29121 image - show images only
29122 text - show text only
29123 both - show both, text below image
29124 both-horiz - show text to the right of the image
29125 text-image-horiz - show text to the left of the image
29126 any other - use system default or image if no system default.
29128 This variable only affects the GTK+ toolkit version of Emacs. */);
29129 Vtool_bar_style
= Qnil
;
29131 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size
,
29132 doc
: /* Maximum number of characters a label can have to be shown.
29133 The tool bar style must also show labels for this to have any effect, see
29134 `tool-bar-style'. */);
29135 tool_bar_max_label_size
= DEFAULT_TOOL_BAR_LABEL_SIZE
;
29137 DEFVAR_LISP ("fontification-functions", Vfontification_functions
,
29138 doc
: /* List of functions to call to fontify regions of text.
29139 Each function is called with one argument POS. Functions must
29140 fontify a region starting at POS in the current buffer, and give
29141 fontified regions the property `fontified'. */);
29142 Vfontification_functions
= Qnil
;
29143 Fmake_variable_buffer_local (Qfontification_functions
);
29145 DEFVAR_BOOL ("unibyte-display-via-language-environment",
29146 unibyte_display_via_language_environment
,
29147 doc
: /* Non-nil means display unibyte text according to language environment.
29148 Specifically, this means that raw bytes in the range 160-255 decimal
29149 are displayed by converting them to the equivalent multibyte characters
29150 according to the current language environment. As a result, they are
29151 displayed according to the current fontset.
29153 Note that this variable affects only how these bytes are displayed,
29154 but does not change the fact they are interpreted as raw bytes. */);
29155 unibyte_display_via_language_environment
= 0;
29157 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height
,
29158 doc
: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
29159 If a float, it specifies a fraction of the mini-window frame's height.
29160 If an integer, it specifies a number of lines. */);
29161 Vmax_mini_window_height
= make_float (0.25);
29163 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows
,
29164 doc
: /* How to resize mini-windows (the minibuffer and the echo area).
29165 A value of nil means don't automatically resize mini-windows.
29166 A value of t means resize them to fit the text displayed in them.
29167 A value of `grow-only', the default, means let mini-windows grow only;
29168 they return to their normal size when the minibuffer is closed, or the
29169 echo area becomes empty. */);
29170 Vresize_mini_windows
= Qgrow_only
;
29172 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist
,
29173 doc
: /* Alist specifying how to blink the cursor off.
29174 Each element has the form (ON-STATE . OFF-STATE). Whenever the
29175 `cursor-type' frame-parameter or variable equals ON-STATE,
29176 comparing using `equal', Emacs uses OFF-STATE to specify
29177 how to blink it off. ON-STATE and OFF-STATE are values for
29178 the `cursor-type' frame parameter.
29180 If a frame's ON-STATE has no entry in this list,
29181 the frame's other specifications determine how to blink the cursor off. */);
29182 Vblink_cursor_alist
= Qnil
;
29184 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p
,
29185 doc
: /* Allow or disallow automatic horizontal scrolling of windows.
29186 If non-nil, windows are automatically scrolled horizontally to make
29187 point visible. */);
29188 automatic_hscrolling_p
= 1;
29189 DEFSYM (Qauto_hscroll_mode
, "auto-hscroll-mode");
29191 DEFVAR_INT ("hscroll-margin", hscroll_margin
,
29192 doc
: /* How many columns away from the window edge point is allowed to get
29193 before automatic hscrolling will horizontally scroll the window. */);
29194 hscroll_margin
= 5;
29196 DEFVAR_LISP ("hscroll-step", Vhscroll_step
,
29197 doc
: /* How many columns to scroll the window when point gets too close to the edge.
29198 When point is less than `hscroll-margin' columns from the window
29199 edge, automatic hscrolling will scroll the window by the amount of columns
29200 determined by this variable. If its value is a positive integer, scroll that
29201 many columns. If it's a positive floating-point number, it specifies the
29202 fraction of the window's width to scroll. If it's nil or zero, point will be
29203 centered horizontally after the scroll. Any other value, including negative
29204 numbers, are treated as if the value were zero.
29206 Automatic hscrolling always moves point outside the scroll margin, so if
29207 point was more than scroll step columns inside the margin, the window will
29208 scroll more than the value given by the scroll step.
29210 Note that the lower bound for automatic hscrolling specified by `scroll-left'
29211 and `scroll-right' overrides this variable's effect. */);
29212 Vhscroll_step
= make_number (0);
29214 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines
,
29215 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
29216 Bind this around calls to `message' to let it take effect. */);
29217 message_truncate_lines
= 0;
29219 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook
,
29220 doc
: /* Normal hook run to update the menu bar definitions.
29221 Redisplay runs this hook before it redisplays the menu bar.
29222 This is used to update submenus such as Buffers,
29223 whose contents depend on various data. */);
29224 Vmenu_bar_update_hook
= Qnil
;
29226 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame
,
29227 doc
: /* Frame for which we are updating a menu.
29228 The enable predicate for a menu binding should check this variable. */);
29229 Vmenu_updating_frame
= Qnil
;
29231 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update
,
29232 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
29233 inhibit_menubar_update
= 0;
29235 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix
,
29236 doc
: /* Prefix prepended to all continuation lines at display time.
29237 The value may be a string, an image, or a stretch-glyph; it is
29238 interpreted in the same way as the value of a `display' text property.
29240 This variable is overridden by any `wrap-prefix' text or overlay
29243 To add a prefix to non-continuation lines, use `line-prefix'. */);
29244 Vwrap_prefix
= Qnil
;
29245 DEFSYM (Qwrap_prefix
, "wrap-prefix");
29246 Fmake_variable_buffer_local (Qwrap_prefix
);
29248 DEFVAR_LISP ("line-prefix", Vline_prefix
,
29249 doc
: /* Prefix prepended to all non-continuation lines at display time.
29250 The value may be a string, an image, or a stretch-glyph; it is
29251 interpreted in the same way as the value of a `display' text property.
29253 This variable is overridden by any `line-prefix' text or overlay
29256 To add a prefix to continuation lines, use `wrap-prefix'. */);
29257 Vline_prefix
= Qnil
;
29258 DEFSYM (Qline_prefix
, "line-prefix");
29259 Fmake_variable_buffer_local (Qline_prefix
);
29261 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay
,
29262 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
29263 inhibit_eval_during_redisplay
= 0;
29265 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces
,
29266 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
29267 inhibit_free_realized_faces
= 0;
29270 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id
,
29271 doc
: /* Inhibit try_window_id display optimization. */);
29272 inhibit_try_window_id
= 0;
29274 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing
,
29275 doc
: /* Inhibit try_window_reusing display optimization. */);
29276 inhibit_try_window_reusing
= 0;
29278 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement
,
29279 doc
: /* Inhibit try_cursor_movement display optimization. */);
29280 inhibit_try_cursor_movement
= 0;
29281 #endif /* GLYPH_DEBUG */
29283 DEFVAR_INT ("overline-margin", overline_margin
,
29284 doc
: /* Space between overline and text, in pixels.
29285 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
29286 margin to the character height. */);
29287 overline_margin
= 2;
29289 DEFVAR_INT ("underline-minimum-offset",
29290 underline_minimum_offset
,
29291 doc
: /* Minimum distance between baseline and underline.
29292 This can improve legibility of underlined text at small font sizes,
29293 particularly when using variable `x-use-underline-position-properties'
29294 with fonts that specify an UNDERLINE_POSITION relatively close to the
29295 baseline. The default value is 1. */);
29296 underline_minimum_offset
= 1;
29298 DEFVAR_BOOL ("display-hourglass", display_hourglass_p
,
29299 doc
: /* Non-nil means show an hourglass pointer, when Emacs is busy.
29300 This feature only works when on a window system that can change
29301 cursor shapes. */);
29302 display_hourglass_p
= 1;
29304 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay
,
29305 doc
: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
29306 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
29308 hourglass_atimer
= NULL
;
29309 hourglass_shown_p
= 0;
29311 DEFSYM (Qglyphless_char
, "glyphless-char");
29312 DEFSYM (Qhex_code
, "hex-code");
29313 DEFSYM (Qempty_box
, "empty-box");
29314 DEFSYM (Qthin_space
, "thin-space");
29315 DEFSYM (Qzero_width
, "zero-width");
29317 DEFSYM (Qglyphless_char_display
, "glyphless-char-display");
29318 /* Intern this now in case it isn't already done.
29319 Setting this variable twice is harmless.
29320 But don't staticpro it here--that is done in alloc.c. */
29321 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
29322 Fput (Qglyphless_char_display
, Qchar_table_extra_slots
, make_number (1));
29324 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display
,
29325 doc
: /* Char-table defining glyphless characters.
29326 Each element, if non-nil, should be one of the following:
29327 an ASCII acronym string: display this string in a box
29328 `hex-code': display the hexadecimal code of a character in a box
29329 `empty-box': display as an empty box
29330 `thin-space': display as 1-pixel width space
29331 `zero-width': don't display
29332 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
29333 display method for graphical terminals and text terminals respectively.
29334 GRAPHICAL and TEXT should each have one of the values listed above.
29336 The char-table has one extra slot to control the display of a character for
29337 which no font is found. This slot only takes effect on graphical terminals.
29338 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
29339 `thin-space'. The default is `empty-box'. */);
29340 Vglyphless_char_display
= Fmake_char_table (Qglyphless_char_display
, Qnil
);
29341 Fset_char_table_extra_slot (Vglyphless_char_display
, make_number (0),
29344 DEFVAR_LISP ("debug-on-message", Vdebug_on_message
,
29345 doc
: /* If non-nil, debug if a message matching this regexp is displayed. */);
29346 Vdebug_on_message
= Qnil
;
29350 /* Initialize this module when Emacs starts. */
29355 current_header_line_height
= current_mode_line_height
= -1;
29357 CHARPOS (this_line_start_pos
) = 0;
29359 if (!noninteractive
)
29361 struct window
*m
= XWINDOW (minibuf_window
);
29362 Lisp_Object frame
= m
->frame
;
29363 struct frame
*f
= XFRAME (frame
);
29364 Lisp_Object root
= FRAME_ROOT_WINDOW (f
);
29365 struct window
*r
= XWINDOW (root
);
29368 echo_area_window
= minibuf_window
;
29370 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
29372 (r
, make_number (FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
)));
29373 wset_total_cols (r
, make_number (FRAME_COLS (f
)));
29374 wset_top_line (m
, make_number (FRAME_LINES (f
) - 1));
29375 wset_total_lines (m
, make_number (1));
29376 wset_total_cols (m
, make_number (FRAME_COLS (f
)));
29378 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
29379 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
29380 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
29382 /* The default ellipsis glyphs `...'. */
29383 for (i
= 0; i
< 3; ++i
)
29384 default_invis_vector
[i
] = make_number ('.');
29388 /* Allocate the buffer for frame titles.
29389 Also used for `format-mode-line'. */
29391 mode_line_noprop_buf
= xmalloc (size
);
29392 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
29393 mode_line_noprop_ptr
= mode_line_noprop_buf
;
29394 mode_line_target
= MODE_LINE_DISPLAY
;
29397 help_echo_showing_p
= 0;
29400 /* Platform-independent portion of hourglass implementation. */
29402 /* Cancel a currently active hourglass timer, and start a new one. */
29404 start_hourglass (void)
29406 #if defined (HAVE_WINDOW_SYSTEM)
29409 cancel_hourglass ();
29411 if (INTEGERP (Vhourglass_delay
)
29412 && XINT (Vhourglass_delay
) > 0)
29413 delay
= make_emacs_time (min (XINT (Vhourglass_delay
),
29414 TYPE_MAXIMUM (time_t)),
29416 else if (FLOATP (Vhourglass_delay
)
29417 && XFLOAT_DATA (Vhourglass_delay
) > 0)
29418 delay
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (Vhourglass_delay
));
29420 delay
= make_emacs_time (DEFAULT_HOURGLASS_DELAY
, 0);
29424 extern void w32_note_current_window (void);
29425 w32_note_current_window ();
29427 #endif /* HAVE_NTGUI */
29429 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
29430 show_hourglass
, NULL
);
29435 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
29438 cancel_hourglass (void)
29440 #if defined (HAVE_WINDOW_SYSTEM)
29441 if (hourglass_atimer
)
29443 cancel_atimer (hourglass_atimer
);
29444 hourglass_atimer
= NULL
;
29447 if (hourglass_shown_p
)