1 /* Display generation from window structure and buffer text.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2014 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
25 Emacs separates the task of updating the display from code
26 modifying global state, e.g. buffer text. This way functions
27 operating on buffers don't also have to be concerned with updating
30 Updating the display is triggered by the Lisp interpreter when it
31 decides it's time to do it. This is done either automatically for
32 you as part of the interpreter's command loop or as the result of
33 calling Lisp functions like `sit-for'. The C function `redisplay'
34 in xdisp.c is the only entry into the inner redisplay code.
36 The following diagram shows how redisplay code is invoked. As you
37 can see, Lisp calls redisplay and vice versa. Under window systems
38 like X, some portions of the redisplay code are also called
39 asynchronously during mouse movement or expose events. It is very
40 important that these code parts do NOT use the C library (malloc,
41 free) because many C libraries under Unix are not reentrant. They
42 may also NOT call functions of the Lisp interpreter which could
43 change the interpreter's state. If you don't follow these rules,
44 you will encounter bugs which are very hard to explain.
46 +--------------+ redisplay +----------------+
47 | Lisp machine |---------------->| Redisplay code |<--+
48 +--------------+ (xdisp.c) +----------------+ |
50 +----------------------------------+ |
51 Don't use this path when called |
54 expose_window (asynchronous) |
56 X expose events -----+
58 What does redisplay do? Obviously, it has to figure out somehow what
59 has been changed since the last time the display has been updated,
60 and to make these changes visible. Preferably it would do that in
61 a moderately intelligent way, i.e. fast.
63 Changes in buffer text can be deduced from window and buffer
64 structures, and from some global variables like `beg_unchanged' and
65 `end_unchanged'. The contents of the display are additionally
66 recorded in a `glyph matrix', a two-dimensional matrix of glyph
67 structures. Each row in such a matrix corresponds to a line on the
68 display, and each glyph in a row corresponds to a column displaying
69 a character, an image, or what else. This matrix is called the
70 `current glyph matrix' or `current matrix' in redisplay
73 For buffer parts that have been changed since the last update, a
74 second glyph matrix is constructed, the so called `desired glyph
75 matrix' or short `desired matrix'. Current and desired matrix are
76 then compared to find a cheap way to update the display, e.g. by
77 reusing part of the display by scrolling lines.
79 You will find a lot of redisplay optimizations when you start
80 looking at the innards of redisplay. The overall goal of all these
81 optimizations is to make redisplay fast because it is done
82 frequently. Some of these optimizations are implemented by the
87 This function tries to update the display if the text in the
88 window did not change and did not scroll, only point moved, and
89 it did not move off the displayed portion of the text.
91 . try_window_reusing_current_matrix
93 This function reuses the current matrix of a window when text
94 has not changed, but the window start changed (e.g., due to
99 This function attempts to redisplay a window by reusing parts of
100 its existing display. It finds and reuses the part that was not
101 changed, and redraws the rest. (The "id" part in the function's
102 name stands for "insert/delete", not for "identification" or
107 This function performs the full redisplay of a single window
108 assuming that its fonts were not changed and that the cursor
109 will not end up in the scroll margins. (Loading fonts requires
110 re-adjustment of dimensions of glyph matrices, which makes this
111 method impossible to use.)
113 These optimizations are tried in sequence (some can be skipped if
114 it is known that they are not applicable). If none of the
115 optimizations were successful, redisplay calls redisplay_windows,
116 which performs a full redisplay of all windows.
118 Note that there's one more important optimization up Emacs's
119 sleeve, but it is related to actually redrawing the potentially
120 changed portions of the window/frame, not to reproducing the
121 desired matrices of those potentially changed portions. Namely,
122 the function update_frame and its subroutines, which you will find
123 in dispnew.c, compare the desired matrices with the current
124 matrices, and only redraw the portions that changed. So it could
125 happen that the functions in this file for some reason decide that
126 the entire desired matrix needs to be regenerated from scratch, and
127 still only parts of the Emacs display, or even nothing at all, will
128 be actually delivered to the glass, because update_frame has found
129 that the new and the old screen contents are similar or identical.
133 Desired matrices are always built per Emacs window. The function
134 `display_line' is the central function to look at if you are
135 interested. It constructs one row in a desired matrix given an
136 iterator structure containing both a buffer position and a
137 description of the environment in which the text is to be
138 displayed. But this is too early, read on.
140 Characters and pixmaps displayed for a range of buffer text depend
141 on various settings of buffers and windows, on overlays and text
142 properties, on display tables, on selective display. The good news
143 is that all this hairy stuff is hidden behind a small set of
144 interface functions taking an iterator structure (struct it)
147 Iteration over things to be displayed is then simple. It is
148 started by initializing an iterator with a call to init_iterator,
149 passing it the buffer position where to start iteration. For
150 iteration over strings, pass -1 as the position to init_iterator,
151 and call reseat_to_string when the string is ready, to initialize
152 the iterator for that string. Thereafter, calls to
153 get_next_display_element fill the iterator structure with relevant
154 information about the next thing to display. Calls to
155 set_iterator_to_next move the iterator to the next thing.
157 Besides this, an iterator also contains information about the
158 display environment in which glyphs for display elements are to be
159 produced. It has fields for the width and height of the display,
160 the information whether long lines are truncated or continued, a
161 current X and Y position, and lots of other stuff you can better
164 Glyphs in a desired matrix are normally constructed in a loop
165 calling get_next_display_element and then PRODUCE_GLYPHS. The call
166 to PRODUCE_GLYPHS will fill the iterator structure with pixel
167 information about the element being displayed and at the same time
168 produce glyphs for it. If the display element fits on the line
169 being displayed, set_iterator_to_next is called next, otherwise the
170 glyphs produced are discarded. The function display_line is the
171 workhorse of filling glyph rows in the desired matrix with glyphs.
172 In addition to producing glyphs, it also handles line truncation
173 and continuation, word wrap, and cursor positioning (for the
174 latter, see also set_cursor_from_row).
178 That just couldn't be all, could it? What about terminal types not
179 supporting operations on sub-windows of the screen? To update the
180 display on such a terminal, window-based glyph matrices are not
181 well suited. To be able to reuse part of the display (scrolling
182 lines up and down), we must instead have a view of the whole
183 screen. This is what `frame matrices' are for. They are a trick.
185 Frames on terminals like above have a glyph pool. Windows on such
186 a frame sub-allocate their glyph memory from their frame's glyph
187 pool. The frame itself is given its own glyph matrices. By
188 coincidence---or maybe something else---rows in window glyph
189 matrices are slices of corresponding rows in frame matrices. Thus
190 writing to window matrices implicitly updates a frame matrix which
191 provides us with the view of the whole screen that we originally
192 wanted to have without having to move many bytes around. To be
193 honest, there is a little bit more done, but not much more. If you
194 plan to extend that code, take a look at dispnew.c. The function
195 build_frame_matrix is a good starting point.
197 Bidirectional display.
199 Bidirectional display adds quite some hair to this already complex
200 design. The good news are that a large portion of that hairy stuff
201 is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
202 reordering engine which is called by set_iterator_to_next and
203 returns the next character to display in the visual order. See
204 commentary on bidi.c for more details. As far as redisplay is
205 concerned, the effect of calling bidi_move_to_visually_next, the
206 main interface of the reordering engine, is that the iterator gets
207 magically placed on the buffer or string position that is to be
208 displayed next. In other words, a linear iteration through the
209 buffer/string is replaced with a non-linear one. All the rest of
210 the redisplay is oblivious to the bidi reordering.
212 Well, almost oblivious---there are still complications, most of
213 them due to the fact that buffer and string positions no longer
214 change monotonously with glyph indices in a glyph row. Moreover,
215 for continued lines, the buffer positions may not even be
216 monotonously changing with vertical positions. Also, accounting
217 for face changes, overlays, etc. becomes more complex because
218 non-linear iteration could potentially skip many positions with
219 changes, and then cross them again on the way back...
221 One other prominent effect of bidirectional display is that some
222 paragraphs of text need to be displayed starting at the right
223 margin of the window---the so-called right-to-left, or R2L
224 paragraphs. R2L paragraphs are displayed with R2L glyph rows,
225 which have their reversed_p flag set. The bidi reordering engine
226 produces characters in such rows starting from the character which
227 should be the rightmost on display. PRODUCE_GLYPHS then reverses
228 the order, when it fills up the glyph row whose reversed_p flag is
229 set, by prepending each new glyph to what is already there, instead
230 of appending it. When the glyph row is complete, the function
231 extend_face_to_end_of_line fills the empty space to the left of the
232 leftmost character with special glyphs, which will display as,
233 well, empty. On text terminals, these special glyphs are simply
234 blank characters. On graphics terminals, there's a single stretch
235 glyph of a suitably computed width. Both the blanks and the
236 stretch glyph are given the face of the background of the line.
237 This way, the terminal-specific back-end can still draw the glyphs
238 left to right, even for R2L lines.
240 Bidirectional display and character compositions
242 Some scripts cannot be displayed by drawing each character
243 individually, because adjacent characters change each other's shape
244 on display. For example, Arabic and Indic scripts belong to this
247 Emacs display supports this by providing "character compositions",
248 most of which is implemented in composite.c. During the buffer
249 scan that delivers characters to PRODUCE_GLYPHS, if the next
250 character to be delivered is a composed character, the iteration
251 calls composition_reseat_it and next_element_from_composition. If
252 they succeed to compose the character with one or more of the
253 following characters, the whole sequence of characters that where
254 composed is recorded in the `struct composition_it' object that is
255 part of the buffer iterator. The composed sequence could produce
256 one or more font glyphs (called "grapheme clusters") on the screen.
257 Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
258 in the direction corresponding to the current bidi scan direction
259 (recorded in the scan_dir member of the `struct bidi_it' object
260 that is part of the buffer iterator). In particular, if the bidi
261 iterator currently scans the buffer backwards, the grapheme
262 clusters are delivered back to front. This reorders the grapheme
263 clusters as appropriate for the current bidi context. Note that
264 this means that the grapheme clusters are always stored in the
265 LGSTRING object (see composite.c) in the logical order.
267 Moving an iterator in bidirectional text
268 without producing glyphs
270 Note one important detail mentioned above: that the bidi reordering
271 engine, driven by the iterator, produces characters in R2L rows
272 starting at the character that will be the rightmost on display.
273 As far as the iterator is concerned, the geometry of such rows is
274 still left to right, i.e. the iterator "thinks" the first character
275 is at the leftmost pixel position. The iterator does not know that
276 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
277 delivers. This is important when functions from the move_it_*
278 family are used to get to certain screen position or to match
279 screen coordinates with buffer coordinates: these functions use the
280 iterator geometry, which is left to right even in R2L paragraphs.
281 This works well with most callers of move_it_*, because they need
282 to get to a specific column, and columns are still numbered in the
283 reading order, i.e. the rightmost character in a R2L paragraph is
284 still column zero. But some callers do not get well with this; a
285 notable example is mouse clicks that need to find the character
286 that corresponds to certain pixel coordinates. See
287 buffer_posn_from_coords in dispnew.c for how this is handled. */
295 #include "keyboard.h"
298 #include "termchar.h"
299 #include "dispextern.h"
300 #include "character.h"
304 #include "commands.h"
308 #include "termhooks.h"
309 #include "termopts.h"
310 #include "intervals.h"
313 #include "region-cache.h"
316 #include "blockinput.h"
317 #ifdef HAVE_WINDOW_SYSTEM
319 #endif /* HAVE_WINDOW_SYSTEM */
321 #ifndef FRAME_X_OUTPUT
322 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
325 #define INFINITY 10000000
327 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
328 Lisp_Object Qwindow_scroll_functions
;
329 static Lisp_Object Qwindow_text_change_functions
;
330 static Lisp_Object Qredisplay_end_trigger_functions
;
331 Lisp_Object Qinhibit_point_motion_hooks
;
332 static Lisp_Object QCeval
, QCpropertize
;
333 Lisp_Object QCfile
, QCdata
;
334 static Lisp_Object Qfontified
;
335 static Lisp_Object Qgrow_only
;
336 static Lisp_Object Qinhibit_eval_during_redisplay
;
337 static Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
338 static Lisp_Object Qright_to_left
, Qleft_to_right
;
341 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
343 /* Pointer shapes. */
344 static Lisp_Object Qarrow
, Qhand
;
347 /* Holds the list (error). */
348 static Lisp_Object list_of_error
;
350 static Lisp_Object Qfontification_functions
;
352 static Lisp_Object Qwrap_prefix
;
353 static Lisp_Object Qline_prefix
;
354 static Lisp_Object Qredisplay_internal
;
356 /* Non-nil means don't actually do any redisplay. */
358 Lisp_Object Qinhibit_redisplay
;
360 /* Names of text properties relevant for redisplay. */
362 Lisp_Object Qdisplay
;
364 Lisp_Object Qspace
, QCalign_to
;
365 static Lisp_Object QCrelative_width
, QCrelative_height
;
366 Lisp_Object Qleft_margin
, Qright_margin
;
367 static Lisp_Object Qspace_width
, Qraise
;
368 static Lisp_Object Qslice
;
370 static Lisp_Object Qmargin
, Qpointer
;
371 static Lisp_Object Qline_height
;
373 #ifdef HAVE_WINDOW_SYSTEM
375 /* Test if overflow newline into fringe. Called with iterator IT
376 at or past right window margin, and with IT->current_x set. */
378 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
379 (!NILP (Voverflow_newline_into_fringe) \
380 && FRAME_WINDOW_P ((IT)->f) \
381 && ((IT)->bidi_it.paragraph_dir == R2L \
382 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
383 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
384 && (IT)->current_x == (IT)->last_visible_x)
386 #else /* !HAVE_WINDOW_SYSTEM */
387 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
388 #endif /* HAVE_WINDOW_SYSTEM */
390 /* Test if the display element loaded in IT, or the underlying buffer
391 or string character, is a space or a TAB character. This is used
392 to determine where word wrapping can occur. */
394 #define IT_DISPLAYING_WHITESPACE(it) \
395 ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t')) \
396 || ((STRINGP (it->string) \
397 && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' ' \
398 || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t')) \
400 && (it->s[IT_BYTEPOS (*it)] == ' ' \
401 || it->s[IT_BYTEPOS (*it)] == '\t')) \
402 || (IT_BYTEPOS (*it) < ZV_BYTE \
403 && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' ' \
404 || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t')))) \
406 /* Name of the face used to highlight trailing whitespace. */
408 static Lisp_Object Qtrailing_whitespace
;
410 /* Name and number of the face used to highlight escape glyphs. */
412 static Lisp_Object Qescape_glyph
;
414 /* Name and number of the face used to highlight non-breaking spaces. */
416 static Lisp_Object Qnobreak_space
;
418 /* The symbol `image' which is the car of the lists used to represent
419 images in Lisp. Also a tool bar style. */
423 /* The image map types. */
425 static Lisp_Object QCpointer
;
426 static Lisp_Object Qrect
, Qcircle
, Qpoly
;
428 /* Tool bar styles */
429 Lisp_Object Qboth
, Qboth_horiz
, Qtext_image_horiz
;
431 /* Non-zero means print newline to stdout before next mini-buffer
434 bool noninteractive_need_newline
;
436 /* Non-zero means print newline to message log before next message. */
438 static bool message_log_need_newline
;
440 /* Three markers that message_dolog uses.
441 It could allocate them itself, but that causes trouble
442 in handling memory-full errors. */
443 static Lisp_Object message_dolog_marker1
;
444 static Lisp_Object message_dolog_marker2
;
445 static Lisp_Object message_dolog_marker3
;
447 /* The buffer position of the first character appearing entirely or
448 partially on the line of the selected window which contains the
449 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
450 redisplay optimization in redisplay_internal. */
452 static struct text_pos this_line_start_pos
;
454 /* Number of characters past the end of the line above, including the
455 terminating newline. */
457 static struct text_pos this_line_end_pos
;
459 /* The vertical positions and the height of this line. */
461 static int this_line_vpos
;
462 static int this_line_y
;
463 static int this_line_pixel_height
;
465 /* X position at which this display line starts. Usually zero;
466 negative if first character is partially visible. */
468 static int this_line_start_x
;
470 /* The smallest character position seen by move_it_* functions as they
471 move across display lines. Used to set MATRIX_ROW_START_CHARPOS of
472 hscrolled lines, see display_line. */
474 static struct text_pos this_line_min_pos
;
476 /* Buffer that this_line_.* variables are referring to. */
478 static struct buffer
*this_line_buffer
;
481 /* Values of those variables at last redisplay are stored as
482 properties on `overlay-arrow-position' symbol. However, if
483 Voverlay_arrow_position is a marker, last-arrow-position is its
484 numerical position. */
486 static Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
488 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
489 properties on a symbol in overlay-arrow-variable-list. */
491 static Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
493 Lisp_Object Qmenu_bar_update_hook
;
495 /* Nonzero if an overlay arrow has been displayed in this window. */
497 static bool overlay_arrow_seen
;
499 /* Vector containing glyphs for an ellipsis `...'. */
501 static Lisp_Object default_invis_vector
[3];
503 /* This is the window where the echo area message was displayed. It
504 is always a mini-buffer window, but it may not be the same window
505 currently active as a mini-buffer. */
507 Lisp_Object echo_area_window
;
509 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
510 pushes the current message and the value of
511 message_enable_multibyte on the stack, the function restore_message
512 pops the stack and displays MESSAGE again. */
514 static Lisp_Object Vmessage_stack
;
516 /* Nonzero means multibyte characters were enabled when the echo area
517 message was specified. */
519 static bool message_enable_multibyte
;
521 /* Nonzero if we should redraw the mode lines on the next redisplay.
522 If it has value REDISPLAY_SOME, then only redisplay the mode lines where
523 the `redisplay' bit has been set. Otherwise, redisplay all mode lines
524 (the number used is then only used to track down the cause for this
527 int update_mode_lines
;
529 /* Nonzero if window sizes or contents other than selected-window have changed
530 since last redisplay that finished.
531 If it has value REDISPLAY_SOME, then only redisplay the windows where
532 the `redisplay' bit has been set. Otherwise, redisplay all windows
533 (the number used is then only used to track down the cause for this
536 int windows_or_buffers_changed
;
538 /* Nonzero after display_mode_line if %l was used and it displayed a
541 static bool line_number_displayed
;
543 /* The name of the *Messages* buffer, a string. */
545 static Lisp_Object Vmessages_buffer_name
;
547 /* Current, index 0, and last displayed echo area message. Either
548 buffers from echo_buffers, or nil to indicate no message. */
550 Lisp_Object echo_area_buffer
[2];
552 /* The buffers referenced from echo_area_buffer. */
554 static Lisp_Object echo_buffer
[2];
556 /* A vector saved used in with_area_buffer to reduce consing. */
558 static Lisp_Object Vwith_echo_area_save_vector
;
560 /* Non-zero means display_echo_area should display the last echo area
561 message again. Set by redisplay_preserve_echo_area. */
563 static bool display_last_displayed_message_p
;
565 /* Nonzero if echo area is being used by print; zero if being used by
568 static bool message_buf_print
;
570 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
572 static Lisp_Object Qinhibit_menubar_update
;
573 static Lisp_Object Qmessage_truncate_lines
;
575 /* Set to 1 in clear_message to make redisplay_internal aware
576 of an emptied echo area. */
578 static bool message_cleared_p
;
580 /* A scratch glyph row with contents used for generating truncation
581 glyphs. Also used in direct_output_for_insert. */
583 #define MAX_SCRATCH_GLYPHS 100
584 static struct glyph_row scratch_glyph_row
;
585 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
587 /* Ascent and height of the last line processed by move_it_to. */
589 static int last_height
;
591 /* Non-zero if there's a help-echo in the echo area. */
593 bool help_echo_showing_p
;
595 /* The maximum distance to look ahead for text properties. Values
596 that are too small let us call compute_char_face and similar
597 functions too often which is expensive. Values that are too large
598 let us call compute_char_face and alike too often because we
599 might not be interested in text properties that far away. */
601 #define TEXT_PROP_DISTANCE_LIMIT 100
603 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
604 iterator state and later restore it. This is needed because the
605 bidi iterator on bidi.c keeps a stacked cache of its states, which
606 is really a singleton. When we use scratch iterator objects to
607 move around the buffer, we can cause the bidi cache to be pushed or
608 popped, and therefore we need to restore the cache state when we
609 return to the original iterator. */
610 #define SAVE_IT(ITCOPY,ITORIG,CACHE) \
613 bidi_unshelve_cache (CACHE, 1); \
615 CACHE = bidi_shelve_cache (); \
618 #define RESTORE_IT(pITORIG,pITCOPY,CACHE) \
620 if (pITORIG != pITCOPY) \
621 *(pITORIG) = *(pITCOPY); \
622 bidi_unshelve_cache (CACHE, 0); \
626 /* Functions to mark elements as needing redisplay. */
627 enum { REDISPLAY_SOME
= 2}; /* Arbitrary choice. */
630 redisplay_other_windows (void)
632 if (!windows_or_buffers_changed
)
633 windows_or_buffers_changed
= REDISPLAY_SOME
;
637 wset_redisplay (struct window
*w
)
639 /* Beware: selected_window can be nil during early stages. */
640 if (!EQ (make_lisp_ptr (w
, Lisp_Vectorlike
), selected_window
))
641 redisplay_other_windows ();
646 fset_redisplay (struct frame
*f
)
648 redisplay_other_windows ();
653 bset_redisplay (struct buffer
*b
)
655 int count
= buffer_window_count (b
);
658 /* ... it's visible in other window than selected, */
659 if (count
> 1 || b
!= XBUFFER (XWINDOW (selected_window
)->contents
))
660 redisplay_other_windows ();
661 /* Even if we don't set windows_or_buffers_changed, do set `redisplay'
662 so that if we later set windows_or_buffers_changed, this buffer will
664 b
->text
->redisplay
= true;
669 bset_update_mode_line (struct buffer
*b
)
671 if (!update_mode_lines
)
672 update_mode_lines
= REDISPLAY_SOME
;
673 b
->text
->redisplay
= true;
678 /* Non-zero means print traces of redisplay if compiled with
679 GLYPH_DEBUG defined. */
681 bool trace_redisplay_p
;
683 #endif /* GLYPH_DEBUG */
685 #ifdef DEBUG_TRACE_MOVE
686 /* Non-zero means trace with TRACE_MOVE to stderr. */
689 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
691 #define TRACE_MOVE(x) (void) 0
694 static Lisp_Object Qauto_hscroll_mode
;
696 /* Buffer being redisplayed -- for redisplay_window_error. */
698 static struct buffer
*displayed_buffer
;
700 /* Value returned from text property handlers (see below). */
705 HANDLED_RECOMPUTE_PROPS
,
706 HANDLED_OVERLAY_STRING_CONSUMED
,
710 /* A description of text properties that redisplay is interested
715 /* The name of the property. */
718 /* A unique index for the property. */
721 /* A handler function called to set up iterator IT from the property
722 at IT's current position. Value is used to steer handle_stop. */
723 enum prop_handled (*handler
) (struct it
*it
);
726 static enum prop_handled
handle_face_prop (struct it
*);
727 static enum prop_handled
handle_invisible_prop (struct it
*);
728 static enum prop_handled
handle_display_prop (struct it
*);
729 static enum prop_handled
handle_composition_prop (struct it
*);
730 static enum prop_handled
handle_overlay_change (struct it
*);
731 static enum prop_handled
handle_fontified_prop (struct it
*);
733 /* Properties handled by iterators. */
735 static struct props it_props
[] =
737 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
738 /* Handle `face' before `display' because some sub-properties of
739 `display' need to know the face. */
740 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
741 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
742 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
743 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
747 /* Value is the position described by X. If X is a marker, value is
748 the marker_position of X. Otherwise, value is X. */
750 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
752 /* Enumeration returned by some move_it_.* functions internally. */
756 /* Not used. Undefined value. */
759 /* Move ended at the requested buffer position or ZV. */
760 MOVE_POS_MATCH_OR_ZV
,
762 /* Move ended at the requested X pixel position. */
765 /* Move within a line ended at the end of a line that must be
769 /* Move within a line ended at the end of a line that would
770 be displayed truncated. */
773 /* Move within a line ended at a line end. */
777 /* This counter is used to clear the face cache every once in a while
778 in redisplay_internal. It is incremented for each redisplay.
779 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
782 #define CLEAR_FACE_CACHE_COUNT 500
783 static int clear_face_cache_count
;
785 /* Similarly for the image cache. */
787 #ifdef HAVE_WINDOW_SYSTEM
788 #define CLEAR_IMAGE_CACHE_COUNT 101
789 static int clear_image_cache_count
;
791 /* Null glyph slice */
792 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
795 /* True while redisplay_internal is in progress. */
799 static Lisp_Object Qinhibit_free_realized_faces
;
800 static Lisp_Object Qmode_line_default_help_echo
;
802 /* If a string, XTread_socket generates an event to display that string.
803 (The display is done in read_char.) */
805 Lisp_Object help_echo_string
;
806 Lisp_Object help_echo_window
;
807 Lisp_Object help_echo_object
;
808 ptrdiff_t help_echo_pos
;
810 /* Temporary variable for XTread_socket. */
812 Lisp_Object previous_help_echo_string
;
814 /* Platform-independent portion of hourglass implementation. */
816 #ifdef HAVE_WINDOW_SYSTEM
818 /* Non-zero means an hourglass cursor is currently shown. */
819 bool hourglass_shown_p
;
821 /* If non-null, an asynchronous timer that, when it expires, displays
822 an hourglass cursor on all frames. */
823 struct atimer
*hourglass_atimer
;
825 #endif /* HAVE_WINDOW_SYSTEM */
827 /* Name of the face used to display glyphless characters. */
828 static Lisp_Object Qglyphless_char
;
830 /* Symbol for the purpose of Vglyphless_char_display. */
831 static Lisp_Object Qglyphless_char_display
;
833 /* Method symbols for Vglyphless_char_display. */
834 static Lisp_Object Qhex_code
, Qempty_box
, Qthin_space
, Qzero_width
;
836 /* Default number of seconds to wait before displaying an hourglass
838 #define DEFAULT_HOURGLASS_DELAY 1
840 #ifdef HAVE_WINDOW_SYSTEM
842 /* Default pixel width of `thin-space' display method. */
843 #define THIN_SPACE_WIDTH 1
845 #endif /* HAVE_WINDOW_SYSTEM */
847 /* Function prototypes. */
849 static void setup_for_ellipsis (struct it
*, int);
850 static void set_iterator_to_next (struct it
*, int);
851 static void mark_window_display_accurate_1 (struct window
*, int);
852 static int single_display_spec_string_p (Lisp_Object
, Lisp_Object
);
853 static int display_prop_string_p (Lisp_Object
, Lisp_Object
);
854 static int row_for_charpos_p (struct glyph_row
*, ptrdiff_t);
855 static int cursor_row_p (struct glyph_row
*);
856 static int redisplay_mode_lines (Lisp_Object
, bool);
857 static char *decode_mode_spec_coding (Lisp_Object
, char *, int);
859 static Lisp_Object
get_it_property (struct it
*it
, Lisp_Object prop
);
861 static void handle_line_prefix (struct it
*);
863 static void pint2str (char *, int, ptrdiff_t);
864 static void pint2hrstr (char *, int, ptrdiff_t);
865 static struct text_pos
run_window_scroll_functions (Lisp_Object
,
867 static int text_outside_line_unchanged_p (struct window
*,
868 ptrdiff_t, ptrdiff_t);
869 static void store_mode_line_noprop_char (char);
870 static int store_mode_line_noprop (const char *, int, int);
871 static void handle_stop (struct it
*);
872 static void handle_stop_backwards (struct it
*, ptrdiff_t);
873 static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
874 static void ensure_echo_area_buffers (void);
875 static void unwind_with_echo_area_buffer (Lisp_Object
);
876 static Lisp_Object
with_echo_area_buffer_unwind_data (struct window
*);
877 static int with_echo_area_buffer (struct window
*, int,
878 int (*) (ptrdiff_t, Lisp_Object
),
879 ptrdiff_t, Lisp_Object
);
880 static void clear_garbaged_frames (void);
881 static int current_message_1 (ptrdiff_t, Lisp_Object
);
882 static int truncate_message_1 (ptrdiff_t, Lisp_Object
);
883 static void set_message (Lisp_Object
);
884 static int set_message_1 (ptrdiff_t, Lisp_Object
);
885 static int display_echo_area (struct window
*);
886 static int display_echo_area_1 (ptrdiff_t, Lisp_Object
);
887 static int resize_mini_window_1 (ptrdiff_t, Lisp_Object
);
888 static void unwind_redisplay (void);
889 static int string_char_and_length (const unsigned char *, int *);
890 static struct text_pos
display_prop_end (struct it
*, Lisp_Object
,
892 static int compute_window_start_on_continuation_line (struct window
*);
893 static void insert_left_trunc_glyphs (struct it
*);
894 static struct glyph_row
*get_overlay_arrow_glyph_row (struct window
*,
896 static void extend_face_to_end_of_line (struct it
*);
897 static int append_space_for_newline (struct it
*, int);
898 static int cursor_row_fully_visible_p (struct window
*, int, int);
899 static int try_scrolling (Lisp_Object
, int, ptrdiff_t, ptrdiff_t, int, int);
900 static int try_cursor_movement (Lisp_Object
, struct text_pos
, int *);
901 static int trailing_whitespace_p (ptrdiff_t);
902 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
903 static void push_it (struct it
*, struct text_pos
*);
904 static void iterate_out_of_display_property (struct it
*);
905 static void pop_it (struct it
*);
906 static void sync_frame_with_window_matrix_rows (struct window
*);
907 static void redisplay_internal (void);
908 static int echo_area_display (int);
909 static void redisplay_windows (Lisp_Object
);
910 static void redisplay_window (Lisp_Object
, bool);
911 static Lisp_Object
redisplay_window_error (Lisp_Object
);
912 static Lisp_Object
redisplay_window_0 (Lisp_Object
);
913 static Lisp_Object
redisplay_window_1 (Lisp_Object
);
914 static int set_cursor_from_row (struct window
*, struct glyph_row
*,
915 struct glyph_matrix
*, ptrdiff_t, ptrdiff_t,
917 static int update_menu_bar (struct frame
*, int, int);
918 static int try_window_reusing_current_matrix (struct window
*);
919 static int try_window_id (struct window
*);
920 static int display_line (struct it
*);
921 static int display_mode_lines (struct window
*);
922 static int display_mode_line (struct window
*, enum face_id
, Lisp_Object
);
923 static int display_mode_element (struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int);
924 static int store_mode_line_string (const char *, Lisp_Object
, int, int, int, Lisp_Object
);
925 static const char *decode_mode_spec (struct window
*, int, int, Lisp_Object
*);
926 static void display_menu_bar (struct window
*);
927 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
929 static int display_string (const char *, Lisp_Object
, Lisp_Object
,
930 ptrdiff_t, ptrdiff_t, struct it
*, int, int, int, int);
931 static void compute_line_metrics (struct it
*);
932 static void run_redisplay_end_trigger_hook (struct it
*);
933 static int get_overlay_strings (struct it
*, ptrdiff_t);
934 static int get_overlay_strings_1 (struct it
*, ptrdiff_t, int);
935 static void next_overlay_string (struct it
*);
936 static void reseat (struct it
*, struct text_pos
, int);
937 static void reseat_1 (struct it
*, struct text_pos
, int);
938 static void back_to_previous_visible_line_start (struct it
*);
939 static void reseat_at_next_visible_line_start (struct it
*, int);
940 static int next_element_from_ellipsis (struct it
*);
941 static int next_element_from_display_vector (struct it
*);
942 static int next_element_from_string (struct it
*);
943 static int next_element_from_c_string (struct it
*);
944 static int next_element_from_buffer (struct it
*);
945 static int next_element_from_composition (struct it
*);
946 static int next_element_from_image (struct it
*);
947 static int next_element_from_stretch (struct it
*);
948 static void load_overlay_strings (struct it
*, ptrdiff_t);
949 static int init_from_display_pos (struct it
*, struct window
*,
950 struct display_pos
*);
951 static void reseat_to_string (struct it
*, const char *,
952 Lisp_Object
, ptrdiff_t, ptrdiff_t, int, int);
953 static int get_next_display_element (struct it
*);
954 static enum move_it_result
955 move_it_in_display_line_to (struct it
*, ptrdiff_t, int,
956 enum move_operation_enum
);
957 static void get_visually_first_element (struct it
*);
958 static void init_to_row_start (struct it
*, struct window
*,
960 static int init_to_row_end (struct it
*, struct window
*,
962 static void back_to_previous_line_start (struct it
*);
963 static int forward_to_next_line_start (struct it
*, int *, struct bidi_it
*);
964 static struct text_pos
string_pos_nchars_ahead (struct text_pos
,
965 Lisp_Object
, ptrdiff_t);
966 static struct text_pos
string_pos (ptrdiff_t, Lisp_Object
);
967 static struct text_pos
c_string_pos (ptrdiff_t, const char *, bool);
968 static ptrdiff_t number_of_chars (const char *, bool);
969 static void compute_stop_pos (struct it
*);
970 static void compute_string_pos (struct text_pos
*, struct text_pos
,
972 static int face_before_or_after_it_pos (struct it
*, int);
973 static ptrdiff_t next_overlay_change (ptrdiff_t);
974 static int handle_display_spec (struct it
*, Lisp_Object
, Lisp_Object
,
975 Lisp_Object
, struct text_pos
*, ptrdiff_t, int);
976 static int handle_single_display_spec (struct it
*, Lisp_Object
,
977 Lisp_Object
, Lisp_Object
,
978 struct text_pos
*, ptrdiff_t, int, int);
979 static int underlying_face_id (struct it
*);
980 static int in_ellipses_for_invisible_text_p (struct display_pos
*,
983 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
984 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
986 #ifdef HAVE_WINDOW_SYSTEM
988 static void x_consider_frame_title (Lisp_Object
);
989 static void update_tool_bar (struct frame
*, int);
990 static int redisplay_tool_bar (struct frame
*);
991 static void x_draw_bottom_divider (struct window
*w
);
992 static void notice_overwritten_cursor (struct window
*,
995 static void append_stretch_glyph (struct it
*, Lisp_Object
,
999 #endif /* HAVE_WINDOW_SYSTEM */
1001 static void produce_special_glyphs (struct it
*, enum display_element_type
);
1002 static void show_mouse_face (Mouse_HLInfo
*, enum draw_glyphs_face
);
1003 static bool coords_in_mouse_face_p (struct window
*, int, int);
1007 /***********************************************************************
1008 Window display dimensions
1009 ***********************************************************************/
1011 /* Return the bottom boundary y-position for text lines in window W.
1012 This is the first y position at which a line cannot start.
1013 It is relative to the top of the window.
1015 This is the height of W minus the height of a mode line, if any. */
1018 window_text_bottom_y (struct window
*w
)
1020 int height
= WINDOW_PIXEL_HEIGHT (w
);
1022 height
-= WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
1024 if (WINDOW_WANTS_MODELINE_P (w
))
1025 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
1030 /* Return the pixel width of display area AREA of window W.
1031 ANY_AREA means return the total width of W, not including
1032 fringes to the left and right of the window. */
1035 window_box_width (struct window
*w
, enum glyph_row_area area
)
1037 int width
= w
->pixel_width
;
1039 if (!w
->pseudo_window_p
)
1041 width
-= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
1042 width
-= WINDOW_RIGHT_DIVIDER_WIDTH (w
);
1044 if (area
== TEXT_AREA
)
1045 width
-= (WINDOW_MARGINS_WIDTH (w
)
1046 + WINDOW_FRINGES_WIDTH (w
));
1047 else if (area
== LEFT_MARGIN_AREA
)
1048 width
= WINDOW_LEFT_MARGIN_WIDTH (w
);
1049 else if (area
== RIGHT_MARGIN_AREA
)
1050 width
= WINDOW_RIGHT_MARGIN_WIDTH (w
);
1053 /* With wide margins, fringes, etc. we might end up with a negative
1054 width, correct that here. */
1055 return max (0, width
);
1059 /* Return the pixel height of the display area of window W, not
1060 including mode lines of W, if any. */
1063 window_box_height (struct window
*w
)
1065 struct frame
*f
= XFRAME (w
->frame
);
1066 int height
= WINDOW_PIXEL_HEIGHT (w
);
1068 eassert (height
>= 0);
1070 height
-= WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
1072 /* Note: the code below that determines the mode-line/header-line
1073 height is essentially the same as that contained in the macro
1074 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1075 the appropriate glyph row has its `mode_line_p' flag set,
1076 and if it doesn't, uses estimate_mode_line_height instead. */
1078 if (WINDOW_WANTS_MODELINE_P (w
))
1080 struct glyph_row
*ml_row
1081 = (w
->current_matrix
&& w
->current_matrix
->rows
1082 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1084 if (ml_row
&& ml_row
->mode_line_p
)
1085 height
-= ml_row
->height
;
1087 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1090 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1092 struct glyph_row
*hl_row
1093 = (w
->current_matrix
&& w
->current_matrix
->rows
1094 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1096 if (hl_row
&& hl_row
->mode_line_p
)
1097 height
-= hl_row
->height
;
1099 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1102 /* With a very small font and a mode-line that's taller than
1103 default, we might end up with a negative height. */
1104 return max (0, height
);
1107 /* Return the window-relative coordinate of the left edge of display
1108 area AREA of window W. ANY_AREA means return the left edge of the
1109 whole window, to the right of the left fringe of W. */
1112 window_box_left_offset (struct window
*w
, enum glyph_row_area area
)
1116 if (w
->pseudo_window_p
)
1119 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1121 if (area
== TEXT_AREA
)
1122 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1123 + window_box_width (w
, LEFT_MARGIN_AREA
));
1124 else if (area
== RIGHT_MARGIN_AREA
)
1125 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1126 + window_box_width (w
, LEFT_MARGIN_AREA
)
1127 + window_box_width (w
, TEXT_AREA
)
1128 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1130 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1131 else if (area
== LEFT_MARGIN_AREA
1132 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1133 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1135 /* Don't return more than the window's pixel width. */
1136 return min (x
, w
->pixel_width
);
1140 /* Return the window-relative coordinate of the right edge of display
1141 area AREA of window W. ANY_AREA means return the right edge of the
1142 whole window, to the left of the right fringe of W. */
1145 window_box_right_offset (struct window
*w
, enum glyph_row_area area
)
1147 /* Don't return more than the window's pixel width. */
1148 return min (window_box_left_offset (w
, area
) + window_box_width (w
, area
),
1152 /* Return the frame-relative coordinate of the left edge of display
1153 area AREA of window W. ANY_AREA means return the left edge of the
1154 whole window, to the right of the left fringe of W. */
1157 window_box_left (struct window
*w
, enum glyph_row_area area
)
1159 struct frame
*f
= XFRAME (w
->frame
);
1162 if (w
->pseudo_window_p
)
1163 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1165 x
= (WINDOW_LEFT_EDGE_X (w
)
1166 + window_box_left_offset (w
, area
));
1172 /* Return the frame-relative coordinate of the right edge of display
1173 area AREA of window W. ANY_AREA means return the right edge of the
1174 whole window, to the left of the right fringe of W. */
1177 window_box_right (struct window
*w
, enum glyph_row_area area
)
1179 return window_box_left (w
, area
) + window_box_width (w
, area
);
1182 /* Get the bounding box of the display area AREA of window W, without
1183 mode lines, in frame-relative coordinates. ANY_AREA means the
1184 whole window, not including the left and right fringes of
1185 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1186 coordinates of the upper-left corner of the box. Return in
1187 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1190 window_box (struct window
*w
, enum glyph_row_area area
, int *box_x
,
1191 int *box_y
, int *box_width
, int *box_height
)
1194 *box_width
= window_box_width (w
, area
);
1196 *box_height
= window_box_height (w
);
1198 *box_x
= window_box_left (w
, area
);
1201 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1202 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1203 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1207 #ifdef HAVE_WINDOW_SYSTEM
1209 /* Get the bounding box of the display area AREA of window W, without
1210 mode lines and both fringes of the window. Return in *TOP_LEFT_X
1211 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1212 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1213 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1217 window_box_edges (struct window
*w
, int *top_left_x
, int *top_left_y
,
1218 int *bottom_right_x
, int *bottom_right_y
)
1220 window_box (w
, ANY_AREA
, top_left_x
, top_left_y
,
1221 bottom_right_x
, bottom_right_y
);
1222 *bottom_right_x
+= *top_left_x
;
1223 *bottom_right_y
+= *top_left_y
;
1226 #endif /* HAVE_WINDOW_SYSTEM */
1228 /***********************************************************************
1230 ***********************************************************************/
1232 /* Return the bottom y-position of the line the iterator IT is in.
1233 This can modify IT's settings. */
1236 line_bottom_y (struct it
*it
)
1238 int line_height
= it
->max_ascent
+ it
->max_descent
;
1239 int line_top_y
= it
->current_y
;
1241 if (line_height
== 0)
1244 line_height
= last_height
;
1245 else if (IT_CHARPOS (*it
) < ZV
)
1247 move_it_by_lines (it
, 1);
1248 line_height
= (it
->max_ascent
|| it
->max_descent
1249 ? it
->max_ascent
+ it
->max_descent
1254 struct glyph_row
*row
= it
->glyph_row
;
1256 /* Use the default character height. */
1257 it
->glyph_row
= NULL
;
1258 it
->what
= IT_CHARACTER
;
1261 PRODUCE_GLYPHS (it
);
1262 line_height
= it
->ascent
+ it
->descent
;
1263 it
->glyph_row
= row
;
1267 return line_top_y
+ line_height
;
1270 DEFUN ("line-pixel-height", Fline_pixel_height
,
1271 Sline_pixel_height
, 0, 0, 0,
1272 doc
: /* Return height in pixels of text line in the selected window.
1274 Value is the height in pixels of the line at point. */)
1279 struct window
*w
= XWINDOW (selected_window
);
1280 struct buffer
*old_buffer
= NULL
;
1283 if (XBUFFER (w
->contents
) != current_buffer
)
1285 old_buffer
= current_buffer
;
1286 set_buffer_internal_1 (XBUFFER (w
->contents
));
1288 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
1289 start_display (&it
, w
, pt
);
1290 it
.vpos
= it
.current_y
= 0;
1292 result
= make_number (line_bottom_y (&it
));
1294 set_buffer_internal_1 (old_buffer
);
1299 /* Return the default pixel height of text lines in window W. The
1300 value is the canonical height of the W frame's default font, plus
1301 any extra space required by the line-spacing variable or frame
1304 Implementation note: this ignores any line-spacing text properties
1305 put on the newline characters. This is because those properties
1306 only affect the _screen_ line ending in the newline (i.e., in a
1307 continued line, only the last screen line will be affected), which
1308 means only a small number of lines in a buffer can ever use this
1309 feature. Since this function is used to compute the default pixel
1310 equivalent of text lines in a window, we can safely ignore those
1311 few lines. For the same reasons, we ignore the line-height
1314 default_line_pixel_height (struct window
*w
)
1316 struct frame
*f
= WINDOW_XFRAME (w
);
1317 int height
= FRAME_LINE_HEIGHT (f
);
1319 if (!FRAME_INITIAL_P (f
) && BUFFERP (w
->contents
))
1321 struct buffer
*b
= XBUFFER (w
->contents
);
1322 Lisp_Object val
= BVAR (b
, extra_line_spacing
);
1325 val
= BVAR (&buffer_defaults
, extra_line_spacing
);
1328 if (RANGED_INTEGERP (0, val
, INT_MAX
))
1329 height
+= XFASTINT (val
);
1330 else if (FLOATP (val
))
1332 int addon
= XFLOAT_DATA (val
) * height
+ 0.5;
1339 height
+= f
->extra_line_spacing
;
1345 /* Subroutine of pos_visible_p below. Extracts a display string, if
1346 any, from the display spec given as its argument. */
1348 string_from_display_spec (Lisp_Object spec
)
1352 while (CONSP (spec
))
1354 if (STRINGP (XCAR (spec
)))
1359 else if (VECTORP (spec
))
1363 for (i
= 0; i
< ASIZE (spec
); i
++)
1365 if (STRINGP (AREF (spec
, i
)))
1366 return AREF (spec
, i
);
1375 /* Limit insanely large values of W->hscroll on frame F to the largest
1376 value that will still prevent first_visible_x and last_visible_x of
1377 'struct it' from overflowing an int. */
1379 window_hscroll_limited (struct window
*w
, struct frame
*f
)
1381 ptrdiff_t window_hscroll
= w
->hscroll
;
1382 int window_text_width
= window_box_width (w
, TEXT_AREA
);
1383 int colwidth
= FRAME_COLUMN_WIDTH (f
);
1385 if (window_hscroll
> (INT_MAX
- window_text_width
) / colwidth
- 1)
1386 window_hscroll
= (INT_MAX
- window_text_width
) / colwidth
- 1;
1388 return window_hscroll
;
1391 /* Return 1 if position CHARPOS is visible in window W.
1392 CHARPOS < 0 means return info about WINDOW_END position.
1393 If visible, set *X and *Y to pixel coordinates of top left corner.
1394 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1395 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1398 pos_visible_p (struct window
*w
, ptrdiff_t charpos
, int *x
, int *y
,
1399 int *rtop
, int *rbot
, int *rowh
, int *vpos
)
1402 void *itdata
= bidi_shelve_cache ();
1403 struct text_pos top
;
1405 struct buffer
*old_buffer
= NULL
;
1407 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w
))))
1410 if (XBUFFER (w
->contents
) != current_buffer
)
1412 old_buffer
= current_buffer
;
1413 set_buffer_internal_1 (XBUFFER (w
->contents
));
1416 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1417 /* Scrolling a minibuffer window via scroll bar when the echo area
1418 shows long text sometimes resets the minibuffer contents behind
1420 if (CHARPOS (top
) > ZV
)
1421 SET_TEXT_POS (top
, BEGV
, BEGV_BYTE
);
1423 /* Compute exact mode line heights. */
1424 if (WINDOW_WANTS_MODELINE_P (w
))
1426 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1427 BVAR (current_buffer
, mode_line_format
));
1429 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1430 w
->header_line_height
1431 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1432 BVAR (current_buffer
, header_line_format
));
1434 start_display (&it
, w
, top
);
1435 move_it_to (&it
, charpos
, -1, it
.last_visible_y
- 1, -1,
1436 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1439 && (((!it
.bidi_p
|| it
.bidi_it
.scan_dir
== 1)
1440 && IT_CHARPOS (it
) >= charpos
)
1441 /* When scanning backwards under bidi iteration, move_it_to
1442 stops at or _before_ CHARPOS, because it stops at or to
1443 the _right_ of the character at CHARPOS. */
1444 || (it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1445 && IT_CHARPOS (it
) <= charpos
)))
1447 /* We have reached CHARPOS, or passed it. How the call to
1448 move_it_to can overshoot: (i) If CHARPOS is on invisible text
1449 or covered by a display property, move_it_to stops at the end
1450 of the invisible text, to the right of CHARPOS. (ii) If
1451 CHARPOS is in a display vector, move_it_to stops on its last
1453 int top_x
= it
.current_x
;
1454 int top_y
= it
.current_y
;
1455 /* Calling line_bottom_y may change it.method, it.position, etc. */
1456 enum it_method it_method
= it
.method
;
1457 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1458 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1460 if (top_y
< window_top_y
)
1461 visible_p
= bottom_y
> window_top_y
;
1462 else if (top_y
< it
.last_visible_y
)
1464 if (bottom_y
>= it
.last_visible_y
1465 && it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1466 && IT_CHARPOS (it
) < charpos
)
1468 /* When the last line of the window is scanned backwards
1469 under bidi iteration, we could be duped into thinking
1470 that we have passed CHARPOS, when in fact move_it_to
1471 simply stopped short of CHARPOS because it reached
1472 last_visible_y. To see if that's what happened, we call
1473 move_it_to again with a slightly larger vertical limit,
1474 and see if it actually moved vertically; if it did, we
1475 didn't really reach CHARPOS, which is beyond window end. */
1476 struct it save_it
= it
;
1477 /* Why 10? because we don't know how many canonical lines
1478 will the height of the next line(s) be. So we guess. */
1479 int ten_more_lines
= 10 * default_line_pixel_height (w
);
1481 move_it_to (&it
, charpos
, -1, bottom_y
+ ten_more_lines
, -1,
1482 MOVE_TO_POS
| MOVE_TO_Y
);
1483 if (it
.current_y
> top_y
)
1490 if (it_method
== GET_FROM_DISPLAY_VECTOR
)
1492 /* We stopped on the last glyph of a display vector.
1493 Try and recompute. Hack alert! */
1494 if (charpos
< 2 || top
.charpos
>= charpos
)
1495 top_x
= it
.glyph_row
->x
;
1498 struct it it2
, it2_prev
;
1499 /* The idea is to get to the previous buffer
1500 position, consume the character there, and use
1501 the pixel coordinates we get after that. But if
1502 the previous buffer position is also displayed
1503 from a display vector, we need to consume all of
1504 the glyphs from that display vector. */
1505 start_display (&it2
, w
, top
);
1506 move_it_to (&it2
, charpos
- 1, -1, -1, -1, MOVE_TO_POS
);
1507 /* If we didn't get to CHARPOS - 1, there's some
1508 replacing display property at that position, and
1509 we stopped after it. That is exactly the place
1510 whose coordinates we want. */
1511 if (IT_CHARPOS (it2
) != charpos
- 1)
1515 /* Iterate until we get out of the display
1516 vector that displays the character at
1519 get_next_display_element (&it2
);
1520 PRODUCE_GLYPHS (&it2
);
1522 set_iterator_to_next (&it2
, 1);
1523 } while (it2
.method
== GET_FROM_DISPLAY_VECTOR
1524 && IT_CHARPOS (it2
) < charpos
);
1526 if (ITERATOR_AT_END_OF_LINE_P (&it2_prev
)
1527 || it2_prev
.current_x
> it2_prev
.last_visible_x
)
1528 top_x
= it
.glyph_row
->x
;
1531 top_x
= it2_prev
.current_x
;
1532 top_y
= it2_prev
.current_y
;
1536 else if (IT_CHARPOS (it
) != charpos
)
1538 Lisp_Object cpos
= make_number (charpos
);
1539 Lisp_Object spec
= Fget_char_property (cpos
, Qdisplay
, Qnil
);
1540 Lisp_Object string
= string_from_display_spec (spec
);
1541 struct text_pos tpos
;
1542 int replacing_spec_p
;
1543 bool newline_in_string
1545 && memchr (SDATA (string
), '\n', SBYTES (string
)));
1547 SET_TEXT_POS (tpos
, charpos
, CHAR_TO_BYTE (charpos
));
1550 && handle_display_spec (NULL
, spec
, Qnil
, Qnil
, &tpos
,
1551 charpos
, FRAME_WINDOW_P (it
.f
)));
1552 /* The tricky code below is needed because there's a
1553 discrepancy between move_it_to and how we set cursor
1554 when PT is at the beginning of a portion of text
1555 covered by a display property or an overlay with a
1556 display property, or the display line ends in a
1557 newline from a display string. move_it_to will stop
1558 _after_ such display strings, whereas
1559 set_cursor_from_row conspires with cursor_row_p to
1560 place the cursor on the first glyph produced from the
1563 /* We have overshoot PT because it is covered by a
1564 display property that replaces the text it covers.
1565 If the string includes embedded newlines, we are also
1566 in the wrong display line. Backtrack to the correct
1567 line, where the display property begins. */
1568 if (replacing_spec_p
)
1570 Lisp_Object startpos
, endpos
;
1571 EMACS_INT start
, end
;
1575 /* Find the first and the last buffer positions
1576 covered by the display string. */
1578 Fnext_single_char_property_change (cpos
, Qdisplay
,
1581 Fprevious_single_char_property_change (endpos
, Qdisplay
,
1583 start
= XFASTINT (startpos
);
1584 end
= XFASTINT (endpos
);
1585 /* Move to the last buffer position before the
1586 display property. */
1587 start_display (&it3
, w
, top
);
1588 move_it_to (&it3
, start
- 1, -1, -1, -1, MOVE_TO_POS
);
1589 /* Move forward one more line if the position before
1590 the display string is a newline or if it is the
1591 rightmost character on a line that is
1592 continued or word-wrapped. */
1593 if (it3
.method
== GET_FROM_BUFFER
1595 || FETCH_BYTE (IT_BYTEPOS (it3
)) == '\n'))
1596 move_it_by_lines (&it3
, 1);
1597 else if (move_it_in_display_line_to (&it3
, -1,
1601 == MOVE_LINE_CONTINUED
)
1603 move_it_by_lines (&it3
, 1);
1604 /* When we are under word-wrap, the #$@%!
1605 move_it_by_lines moves 2 lines, so we need to
1607 if (it3
.line_wrap
== WORD_WRAP
)
1608 move_it_by_lines (&it3
, -1);
1611 /* Record the vertical coordinate of the display
1612 line where we wound up. */
1613 top_y
= it3
.current_y
;
1616 /* When characters are reordered for display,
1617 the character displayed to the left of the
1618 display string could be _after_ the display
1619 property in the logical order. Use the
1620 smallest vertical position of these two. */
1621 start_display (&it3
, w
, top
);
1622 move_it_to (&it3
, end
+ 1, -1, -1, -1, MOVE_TO_POS
);
1623 if (it3
.current_y
< top_y
)
1624 top_y
= it3
.current_y
;
1626 /* Move from the top of the window to the beginning
1627 of the display line where the display string
1629 start_display (&it3
, w
, top
);
1630 move_it_to (&it3
, -1, 0, top_y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
1631 /* If it3_moved stays zero after the 'while' loop
1632 below, that means we already were at a newline
1633 before the loop (e.g., the display string begins
1634 with a newline), so we don't need to (and cannot)
1635 inspect the glyphs of it3.glyph_row, because
1636 PRODUCE_GLYPHS will not produce anything for a
1637 newline, and thus it3.glyph_row stays at its
1638 stale content it got at top of the window. */
1640 /* Finally, advance the iterator until we hit the
1641 first display element whose character position is
1642 CHARPOS, or until the first newline from the
1643 display string, which signals the end of the
1645 while (get_next_display_element (&it3
))
1647 PRODUCE_GLYPHS (&it3
);
1648 if (IT_CHARPOS (it3
) == charpos
1649 || ITERATOR_AT_END_OF_LINE_P (&it3
))
1652 set_iterator_to_next (&it3
, 0);
1654 top_x
= it3
.current_x
- it3
.pixel_width
;
1655 /* Normally, we would exit the above loop because we
1656 found the display element whose character
1657 position is CHARPOS. For the contingency that we
1658 didn't, and stopped at the first newline from the
1659 display string, move back over the glyphs
1660 produced from the string, until we find the
1661 rightmost glyph not from the string. */
1663 && newline_in_string
1664 && IT_CHARPOS (it3
) != charpos
&& EQ (it3
.object
, string
))
1666 struct glyph
*g
= it3
.glyph_row
->glyphs
[TEXT_AREA
]
1667 + it3
.glyph_row
->used
[TEXT_AREA
];
1669 while (EQ ((g
- 1)->object
, string
))
1672 top_x
-= g
->pixel_width
;
1674 eassert (g
< it3
.glyph_row
->glyphs
[TEXT_AREA
]
1675 + it3
.glyph_row
->used
[TEXT_AREA
]);
1681 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1682 *rtop
= max (0, window_top_y
- top_y
);
1683 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1684 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1685 - max (top_y
, window_top_y
)));
1691 /* We were asked to provide info about WINDOW_END. */
1693 void *it2data
= NULL
;
1695 SAVE_IT (it2
, it
, it2data
);
1696 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1697 move_it_by_lines (&it
, 1);
1698 if (charpos
< IT_CHARPOS (it
)
1699 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1702 RESTORE_IT (&it2
, &it2
, it2data
);
1703 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1705 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1706 *rtop
= max (0, -it2
.current_y
);
1707 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1708 - it
.last_visible_y
));
1709 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1711 - max (it2
.current_y
,
1712 WINDOW_HEADER_LINE_HEIGHT (w
))));
1716 bidi_unshelve_cache (it2data
, 1);
1718 bidi_unshelve_cache (itdata
, 0);
1721 set_buffer_internal_1 (old_buffer
);
1723 if (visible_p
&& w
->hscroll
> 0)
1725 window_hscroll_limited (w
, WINDOW_XFRAME (w
))
1726 * WINDOW_FRAME_COLUMN_WIDTH (w
);
1729 /* Debugging code. */
1731 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1732 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1734 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1741 /* Return the next character from STR. Return in *LEN the length of
1742 the character. This is like STRING_CHAR_AND_LENGTH but never
1743 returns an invalid character. If we find one, we return a `?', but
1744 with the length of the invalid character. */
1747 string_char_and_length (const unsigned char *str
, int *len
)
1751 c
= STRING_CHAR_AND_LENGTH (str
, *len
);
1752 if (!CHAR_VALID_P (c
))
1753 /* We may not change the length here because other places in Emacs
1754 don't use this function, i.e. they silently accept invalid
1763 /* Given a position POS containing a valid character and byte position
1764 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1766 static struct text_pos
1767 string_pos_nchars_ahead (struct text_pos pos
, Lisp_Object string
, ptrdiff_t nchars
)
1769 eassert (STRINGP (string
) && nchars
>= 0);
1771 if (STRING_MULTIBYTE (string
))
1773 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1778 string_char_and_length (p
, &len
);
1781 BYTEPOS (pos
) += len
;
1785 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1791 /* Value is the text position, i.e. character and byte position,
1792 for character position CHARPOS in STRING. */
1794 static struct text_pos
1795 string_pos (ptrdiff_t charpos
, Lisp_Object string
)
1797 struct text_pos pos
;
1798 eassert (STRINGP (string
));
1799 eassert (charpos
>= 0);
1800 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1805 /* Value is a text position, i.e. character and byte position, for
1806 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1807 means recognize multibyte characters. */
1809 static struct text_pos
1810 c_string_pos (ptrdiff_t charpos
, const char *s
, bool multibyte_p
)
1812 struct text_pos pos
;
1814 eassert (s
!= NULL
);
1815 eassert (charpos
>= 0);
1821 SET_TEXT_POS (pos
, 0, 0);
1824 string_char_and_length ((const unsigned char *) s
, &len
);
1827 BYTEPOS (pos
) += len
;
1831 SET_TEXT_POS (pos
, charpos
, charpos
);
1837 /* Value is the number of characters in C string S. MULTIBYTE_P
1838 non-zero means recognize multibyte characters. */
1841 number_of_chars (const char *s
, bool multibyte_p
)
1847 ptrdiff_t rest
= strlen (s
);
1849 const unsigned char *p
= (const unsigned char *) s
;
1851 for (nchars
= 0; rest
> 0; ++nchars
)
1853 string_char_and_length (p
, &len
);
1854 rest
-= len
, p
+= len
;
1858 nchars
= strlen (s
);
1864 /* Compute byte position NEWPOS->bytepos corresponding to
1865 NEWPOS->charpos. POS is a known position in string STRING.
1866 NEWPOS->charpos must be >= POS.charpos. */
1869 compute_string_pos (struct text_pos
*newpos
, struct text_pos pos
, Lisp_Object string
)
1871 eassert (STRINGP (string
));
1872 eassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1874 if (STRING_MULTIBYTE (string
))
1875 *newpos
= string_pos_nchars_ahead (pos
, string
,
1876 CHARPOS (*newpos
) - CHARPOS (pos
));
1878 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1882 Return an estimation of the pixel height of mode or header lines on
1883 frame F. FACE_ID specifies what line's height to estimate. */
1886 estimate_mode_line_height (struct frame
*f
, enum face_id face_id
)
1888 #ifdef HAVE_WINDOW_SYSTEM
1889 if (FRAME_WINDOW_P (f
))
1891 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1893 /* This function is called so early when Emacs starts that the face
1894 cache and mode line face are not yet initialized. */
1895 if (FRAME_FACE_CACHE (f
))
1897 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1901 height
= FONT_HEIGHT (face
->font
);
1902 if (face
->box_line_width
> 0)
1903 height
+= 2 * face
->box_line_width
;
1914 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1915 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1916 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1917 not force the value into range. */
1920 pixel_to_glyph_coords (struct frame
*f
, register int pix_x
, register int pix_y
,
1921 int *x
, int *y
, NativeRectangle
*bounds
, int noclip
)
1924 #ifdef HAVE_WINDOW_SYSTEM
1925 if (FRAME_WINDOW_P (f
))
1927 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1928 even for negative values. */
1930 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1932 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1934 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1935 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1938 STORE_NATIVE_RECT (*bounds
,
1939 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1940 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1941 FRAME_COLUMN_WIDTH (f
) - 1,
1942 FRAME_LINE_HEIGHT (f
) - 1);
1944 /* PXW: Should we clip pixels before converting to columns/lines? */
1949 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1950 pix_x
= FRAME_TOTAL_COLS (f
);
1954 else if (pix_y
> FRAME_LINES (f
))
1955 pix_y
= FRAME_LINES (f
);
1965 /* Find the glyph under window-relative coordinates X/Y in window W.
1966 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1967 strings. Return in *HPOS and *VPOS the row and column number of
1968 the glyph found. Return in *AREA the glyph area containing X.
1969 Value is a pointer to the glyph found or null if X/Y is not on
1970 text, or we can't tell because W's current matrix is not up to
1973 static struct glyph
*
1974 x_y_to_hpos_vpos (struct window
*w
, int x
, int y
, int *hpos
, int *vpos
,
1975 int *dx
, int *dy
, int *area
)
1977 struct glyph
*glyph
, *end
;
1978 struct glyph_row
*row
= NULL
;
1981 /* Find row containing Y. Give up if some row is not enabled. */
1982 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1984 row
= MATRIX_ROW (w
->current_matrix
, i
);
1985 if (!row
->enabled_p
)
1987 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1994 /* Give up if Y is not in the window. */
1995 if (i
== w
->current_matrix
->nrows
)
1998 /* Get the glyph area containing X. */
1999 if (w
->pseudo_window_p
)
2006 if (x
< window_box_left_offset (w
, TEXT_AREA
))
2008 *area
= LEFT_MARGIN_AREA
;
2009 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
2011 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
2014 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
2018 *area
= RIGHT_MARGIN_AREA
;
2019 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
2023 /* Find glyph containing X. */
2024 glyph
= row
->glyphs
[*area
];
2025 end
= glyph
+ row
->used
[*area
];
2027 while (glyph
< end
&& x
>= glyph
->pixel_width
)
2029 x
-= glyph
->pixel_width
;
2039 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
2042 *hpos
= glyph
- row
->glyphs
[*area
];
2046 /* Convert frame-relative x/y to coordinates relative to window W.
2047 Takes pseudo-windows into account. */
2050 frame_to_window_pixel_xy (struct window
*w
, int *x
, int *y
)
2052 if (w
->pseudo_window_p
)
2054 /* A pseudo-window is always full-width, and starts at the
2055 left edge of the frame, plus a frame border. */
2056 struct frame
*f
= XFRAME (w
->frame
);
2057 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
2058 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
2062 *x
-= WINDOW_LEFT_EDGE_X (w
);
2063 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
2067 #ifdef HAVE_WINDOW_SYSTEM
2070 Return in RECTS[] at most N clipping rectangles for glyph string S.
2071 Return the number of stored rectangles. */
2074 get_glyph_string_clip_rects (struct glyph_string
*s
, NativeRectangle
*rects
, int n
)
2081 if (s
->row
->full_width_p
)
2083 /* Draw full-width. X coordinates are relative to S->w->left_col. */
2084 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
2085 if (s
->row
->mode_line_p
)
2086 r
.width
= WINDOW_PIXEL_WIDTH (s
->w
) - WINDOW_RIGHT_DIVIDER_WIDTH (s
->w
);
2088 r
.width
= WINDOW_PIXEL_WIDTH (s
->w
);
2090 /* Unless displaying a mode or menu bar line, which are always
2091 fully visible, clip to the visible part of the row. */
2092 if (s
->w
->pseudo_window_p
)
2093 r
.height
= s
->row
->visible_height
;
2095 r
.height
= s
->height
;
2099 /* This is a text line that may be partially visible. */
2100 r
.x
= window_box_left (s
->w
, s
->area
);
2101 r
.width
= window_box_width (s
->w
, s
->area
);
2102 r
.height
= s
->row
->visible_height
;
2106 if (r
.x
< s
->clip_head
->x
)
2108 if (r
.width
>= s
->clip_head
->x
- r
.x
)
2109 r
.width
-= s
->clip_head
->x
- r
.x
;
2112 r
.x
= s
->clip_head
->x
;
2115 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
2117 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
2118 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
2123 /* If S draws overlapping rows, it's sufficient to use the top and
2124 bottom of the window for clipping because this glyph string
2125 intentionally draws over other lines. */
2126 if (s
->for_overlaps
)
2128 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2129 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
2131 /* Alas, the above simple strategy does not work for the
2132 environments with anti-aliased text: if the same text is
2133 drawn onto the same place multiple times, it gets thicker.
2134 If the overlap we are processing is for the erased cursor, we
2135 take the intersection with the rectangle of the cursor. */
2136 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
2138 XRectangle rc
, r_save
= r
;
2140 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
2141 rc
.y
= s
->w
->phys_cursor
.y
;
2142 rc
.width
= s
->w
->phys_cursor_width
;
2143 rc
.height
= s
->w
->phys_cursor_height
;
2145 x_intersect_rectangles (&r_save
, &rc
, &r
);
2150 /* Don't use S->y for clipping because it doesn't take partially
2151 visible lines into account. For example, it can be negative for
2152 partially visible lines at the top of a window. */
2153 if (!s
->row
->full_width_p
2154 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2155 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2157 r
.y
= max (0, s
->row
->y
);
2160 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
2162 /* If drawing the cursor, don't let glyph draw outside its
2163 advertised boundaries. Cleartype does this under some circumstances. */
2164 if (s
->hl
== DRAW_CURSOR
)
2166 struct glyph
*glyph
= s
->first_glyph
;
2171 r
.width
-= s
->x
- r
.x
;
2174 r
.width
= min (r
.width
, glyph
->pixel_width
);
2176 /* If r.y is below window bottom, ensure that we still see a cursor. */
2177 height
= min (glyph
->ascent
+ glyph
->descent
,
2178 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
2179 max_y
= window_text_bottom_y (s
->w
) - height
;
2180 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
2181 if (s
->ybase
- glyph
->ascent
> max_y
)
2188 /* Don't draw cursor glyph taller than our actual glyph. */
2189 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
2190 if (height
< r
.height
)
2192 max_y
= r
.y
+ r
.height
;
2193 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
2194 r
.height
= min (max_y
- r
.y
, height
);
2201 XRectangle r_save
= r
;
2203 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
2207 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
2208 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
2210 #ifdef CONVERT_FROM_XRECT
2211 CONVERT_FROM_XRECT (r
, *rects
);
2219 /* If we are processing overlapping and allowed to return
2220 multiple clipping rectangles, we exclude the row of the glyph
2221 string from the clipping rectangle. This is to avoid drawing
2222 the same text on the environment with anti-aliasing. */
2223 #ifdef CONVERT_FROM_XRECT
2226 XRectangle
*rs
= rects
;
2228 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
2230 if (s
->for_overlaps
& OVERLAPS_PRED
)
2233 if (r
.y
+ r
.height
> row_y
)
2236 rs
[i
].height
= row_y
- r
.y
;
2242 if (s
->for_overlaps
& OVERLAPS_SUCC
)
2245 if (r
.y
< row_y
+ s
->row
->visible_height
)
2247 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
2249 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
2250 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
2259 #ifdef CONVERT_FROM_XRECT
2260 for (i
= 0; i
< n
; i
++)
2261 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
2268 Return in *NR the clipping rectangle for glyph string S. */
2271 get_glyph_string_clip_rect (struct glyph_string
*s
, NativeRectangle
*nr
)
2273 get_glyph_string_clip_rects (s
, nr
, 1);
2278 Return the position and height of the phys cursor in window W.
2279 Set w->phys_cursor_width to width of phys cursor.
2283 get_phys_cursor_geometry (struct window
*w
, struct glyph_row
*row
,
2284 struct glyph
*glyph
, int *xp
, int *yp
, int *heightp
)
2286 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2287 int x
, y
, wd
, h
, h0
, y0
;
2289 /* Compute the width of the rectangle to draw. If on a stretch
2290 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2291 rectangle as wide as the glyph, but use a canonical character
2293 wd
= glyph
->pixel_width
- 1;
2294 #if defined (HAVE_NTGUI) || defined (HAVE_NS)
2298 x
= w
->phys_cursor
.x
;
2305 if (glyph
->type
== STRETCH_GLYPH
2306 && !x_stretch_cursor_p
)
2307 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
2308 w
->phys_cursor_width
= wd
;
2310 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
2312 /* If y is below window bottom, ensure that we still see a cursor. */
2313 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
2315 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
2316 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
2318 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
2321 h
= max (h
- (y0
- y
) + 1, h0
);
2326 y0
= window_text_bottom_y (w
) - h0
;
2334 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
2335 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
2340 * Remember which glyph the mouse is over.
2344 remember_mouse_glyph (struct frame
*f
, int gx
, int gy
, NativeRectangle
*rect
)
2348 struct glyph_row
*r
, *gr
, *end_row
;
2349 enum window_part part
;
2350 enum glyph_row_area area
;
2351 int x
, y
, width
, height
;
2353 /* Try to determine frame pixel position and size of the glyph under
2354 frame pixel coordinates X/Y on frame F. */
2356 if (window_resize_pixelwise
)
2361 else if (!f
->glyphs_initialized_p
2362 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, 0),
2365 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2366 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2370 w
= XWINDOW (window
);
2371 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
2372 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
2374 x
= window_relative_x_coord (w
, part
, gx
);
2375 y
= gy
- WINDOW_TOP_EDGE_Y (w
);
2377 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
2378 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
2380 if (w
->pseudo_window_p
)
2383 part
= ON_MODE_LINE
; /* Don't adjust margin. */
2389 case ON_LEFT_MARGIN
:
2390 area
= LEFT_MARGIN_AREA
;
2393 case ON_RIGHT_MARGIN
:
2394 area
= RIGHT_MARGIN_AREA
;
2397 case ON_HEADER_LINE
:
2399 gr
= (part
== ON_HEADER_LINE
2400 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
2401 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
2404 goto text_glyph_row_found
;
2411 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2412 if (r
->y
+ r
->height
> y
)
2418 text_glyph_row_found
:
2421 struct glyph
*g
= gr
->glyphs
[area
];
2422 struct glyph
*end
= g
+ gr
->used
[area
];
2424 height
= gr
->height
;
2425 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2426 if (gx
+ g
->pixel_width
> x
)
2431 if (g
->type
== IMAGE_GLYPH
)
2433 /* Don't remember when mouse is over image, as
2434 image may have hot-spots. */
2435 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2438 width
= g
->pixel_width
;
2442 /* Use nominal char spacing at end of line. */
2444 gx
+= (x
/ width
) * width
;
2447 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2449 gx
+= window_box_left_offset (w
, area
);
2450 /* Don't expand over the modeline to make sure the vertical
2451 drag cursor is shown early enough. */
2452 height
= min (height
,
2453 max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
) - gy
));
2458 /* Use nominal line height at end of window. */
2459 gx
= (x
/ width
) * width
;
2461 gy
+= (y
/ height
) * height
;
2462 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2463 /* See comment above. */
2464 height
= min (height
,
2465 max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
) - gy
));
2469 case ON_LEFT_FRINGE
:
2470 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2471 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2472 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2473 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2476 case ON_RIGHT_FRINGE
:
2477 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2478 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2479 : window_box_right_offset (w
, TEXT_AREA
));
2480 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
) == 0
2481 && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w
)
2482 && !WINDOW_RIGHTMOST_P (w
))
2483 if (gx
< WINDOW_PIXEL_WIDTH (w
) - width
)
2484 /* Make sure the vertical border can get her own glyph to the
2485 right of the one we build here. */
2486 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
) - width
;
2488 width
= WINDOW_PIXEL_WIDTH (w
) - gx
;
2490 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2494 case ON_VERTICAL_BORDER
:
2495 gx
= WINDOW_PIXEL_WIDTH (w
) - width
;
2499 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2501 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2502 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2503 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2505 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2509 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2510 if (r
->y
+ r
->height
> y
)
2517 height
= gr
->height
;
2520 /* Use nominal line height at end of window. */
2522 gy
+= (y
/ height
) * height
;
2526 case ON_RIGHT_DIVIDER
:
2527 gx
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
2528 width
= WINDOW_RIGHT_DIVIDER_WIDTH (w
);
2530 /* The bottom divider prevails. */
2531 height
= WINDOW_PIXEL_HEIGHT (w
) - WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
2534 case ON_BOTTOM_DIVIDER
:
2536 width
= WINDOW_PIXEL_WIDTH (w
);
2537 gy
= WINDOW_PIXEL_HEIGHT (w
) - WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
2538 height
= WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
2544 /* If there is no glyph under the mouse, then we divide the screen
2545 into a grid of the smallest glyph in the frame, and use that
2548 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2549 round down even for negative values. */
2555 gx
= (gx
/ width
) * width
;
2556 gy
= (gy
/ height
) * height
;
2562 gx
+= WINDOW_LEFT_EDGE_X (w
);
2563 gy
+= WINDOW_TOP_EDGE_Y (w
);
2566 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2568 /* Visible feedback for debugging. */
2571 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2572 f
->output_data
.x
->normal_gc
,
2573 gx
, gy
, width
, height
);
2579 #endif /* HAVE_WINDOW_SYSTEM */
2582 adjust_window_ends (struct window
*w
, struct glyph_row
*row
, bool current
)
2585 w
->window_end_pos
= Z
- MATRIX_ROW_END_CHARPOS (row
);
2586 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
2588 = MATRIX_ROW_VPOS (row
, current
? w
->current_matrix
: w
->desired_matrix
);
2591 /***********************************************************************
2592 Lisp form evaluation
2593 ***********************************************************************/
2595 /* Error handler for safe_eval and safe_call. */
2598 safe_eval_handler (Lisp_Object arg
, ptrdiff_t nargs
, Lisp_Object
*args
)
2600 add_to_log ("Error during redisplay: %S signaled %S",
2601 Flist (nargs
, args
), arg
);
2605 /* Call function FUNC with the rest of NARGS - 1 arguments
2606 following. Return the result, or nil if something went
2607 wrong. Prevent redisplay during the evaluation. */
2610 safe__call (bool inhibit_quit
, ptrdiff_t nargs
, Lisp_Object func
, va_list ap
)
2614 if (inhibit_eval_during_redisplay
)
2619 ptrdiff_t count
= SPECPDL_INDEX ();
2620 struct gcpro gcpro1
;
2621 Lisp_Object
*args
= alloca (nargs
* word_size
);
2624 for (i
= 1; i
< nargs
; i
++)
2625 args
[i
] = va_arg (ap
, Lisp_Object
);
2628 gcpro1
.nvars
= nargs
;
2629 specbind (Qinhibit_redisplay
, Qt
);
2631 specbind (Qinhibit_quit
, Qt
);
2632 /* Use Qt to ensure debugger does not run,
2633 so there is no possibility of wanting to redisplay. */
2634 val
= internal_condition_case_n (Ffuncall
, nargs
, args
, Qt
,
2637 val
= unbind_to (count
, val
);
2644 safe_call (ptrdiff_t nargs
, Lisp_Object func
, ...)
2649 va_start (ap
, func
);
2650 retval
= safe__call (false, nargs
, func
, ap
);
2655 /* Call function FN with one argument ARG.
2656 Return the result, or nil if something went wrong. */
2659 safe_call1 (Lisp_Object fn
, Lisp_Object arg
)
2661 return safe_call (2, fn
, arg
);
2665 safe__call1 (bool inhibit_quit
, Lisp_Object fn
, ...)
2671 retval
= safe__call (inhibit_quit
, 2, fn
, ap
);
2676 static Lisp_Object Qeval
;
2679 safe_eval (Lisp_Object sexpr
)
2681 return safe__call1 (false, Qeval
, sexpr
);
2685 safe__eval (bool inhibit_quit
, Lisp_Object sexpr
)
2687 return safe__call1 (inhibit_quit
, Qeval
, sexpr
);
2690 /* Call function FN with two arguments ARG1 and ARG2.
2691 Return the result, or nil if something went wrong. */
2694 safe_call2 (Lisp_Object fn
, Lisp_Object arg1
, Lisp_Object arg2
)
2696 return safe_call (3, fn
, arg1
, arg2
);
2701 /***********************************************************************
2703 ***********************************************************************/
2707 /* Define CHECK_IT to perform sanity checks on iterators.
2708 This is for debugging. It is too slow to do unconditionally. */
2711 check_it (struct it
*it
)
2713 if (it
->method
== GET_FROM_STRING
)
2715 eassert (STRINGP (it
->string
));
2716 eassert (IT_STRING_CHARPOS (*it
) >= 0);
2720 eassert (IT_STRING_CHARPOS (*it
) < 0);
2721 if (it
->method
== GET_FROM_BUFFER
)
2723 /* Check that character and byte positions agree. */
2724 eassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2729 eassert (it
->current
.dpvec_index
>= 0);
2731 eassert (it
->current
.dpvec_index
< 0);
2734 #define CHECK_IT(IT) check_it ((IT))
2738 #define CHECK_IT(IT) (void) 0
2743 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2745 /* Check that the window end of window W is what we expect it
2746 to be---the last row in the current matrix displaying text. */
2749 check_window_end (struct window
*w
)
2751 if (!MINI_WINDOW_P (w
) && w
->window_end_valid
)
2753 struct glyph_row
*row
;
2754 eassert ((row
= MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
),
2756 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2757 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2761 #define CHECK_WINDOW_END(W) check_window_end ((W))
2765 #define CHECK_WINDOW_END(W) (void) 0
2767 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
2769 /***********************************************************************
2770 Iterator initialization
2771 ***********************************************************************/
2773 /* Initialize IT for displaying current_buffer in window W, starting
2774 at character position CHARPOS. CHARPOS < 0 means that no buffer
2775 position is specified which is useful when the iterator is assigned
2776 a position later. BYTEPOS is the byte position corresponding to
2779 If ROW is not null, calls to produce_glyphs with IT as parameter
2780 will produce glyphs in that row.
2782 BASE_FACE_ID is the id of a base face to use. It must be one of
2783 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2784 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2785 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2787 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2788 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2789 will be initialized to use the corresponding mode line glyph row of
2790 the desired matrix of W. */
2793 init_iterator (struct it
*it
, struct window
*w
,
2794 ptrdiff_t charpos
, ptrdiff_t bytepos
,
2795 struct glyph_row
*row
, enum face_id base_face_id
)
2797 enum face_id remapped_base_face_id
= base_face_id
;
2799 /* Some precondition checks. */
2800 eassert (w
!= NULL
&& it
!= NULL
);
2801 eassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2804 /* If face attributes have been changed since the last redisplay,
2805 free realized faces now because they depend on face definitions
2806 that might have changed. Don't free faces while there might be
2807 desired matrices pending which reference these faces. */
2808 if (face_change_count
&& !inhibit_free_realized_faces
)
2810 face_change_count
= 0;
2811 free_all_realized_faces (Qnil
);
2814 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2815 if (! NILP (Vface_remapping_alist
))
2816 remapped_base_face_id
2817 = lookup_basic_face (XFRAME (w
->frame
), base_face_id
);
2819 /* Use one of the mode line rows of W's desired matrix if
2823 if (base_face_id
== MODE_LINE_FACE_ID
2824 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2825 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2826 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2827 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2831 memset (it
, 0, sizeof *it
);
2832 it
->current
.overlay_string_index
= -1;
2833 it
->current
.dpvec_index
= -1;
2834 it
->base_face_id
= remapped_base_face_id
;
2836 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2837 it
->paragraph_embedding
= L2R
;
2838 it
->bidi_it
.string
.lstring
= Qnil
;
2839 it
->bidi_it
.string
.s
= NULL
;
2840 it
->bidi_it
.string
.bufpos
= 0;
2843 /* The window in which we iterate over current_buffer: */
2844 XSETWINDOW (it
->window
, w
);
2846 it
->f
= XFRAME (w
->frame
);
2850 /* Extra space between lines (on window systems only). */
2851 if (base_face_id
== DEFAULT_FACE_ID
2852 && FRAME_WINDOW_P (it
->f
))
2854 if (NATNUMP (BVAR (current_buffer
, extra_line_spacing
)))
2855 it
->extra_line_spacing
= XFASTINT (BVAR (current_buffer
, extra_line_spacing
));
2856 else if (FLOATP (BVAR (current_buffer
, extra_line_spacing
)))
2857 it
->extra_line_spacing
= (XFLOAT_DATA (BVAR (current_buffer
, extra_line_spacing
))
2858 * FRAME_LINE_HEIGHT (it
->f
));
2859 else if (it
->f
->extra_line_spacing
> 0)
2860 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2861 it
->max_extra_line_spacing
= 0;
2864 /* If realized faces have been removed, e.g. because of face
2865 attribute changes of named faces, recompute them. When running
2866 in batch mode, the face cache of the initial frame is null. If
2867 we happen to get called, make a dummy face cache. */
2868 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2869 init_frame_faces (it
->f
);
2870 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2871 recompute_basic_faces (it
->f
);
2873 /* Current value of the `slice', `space-width', and 'height' properties. */
2874 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2875 it
->space_width
= Qnil
;
2876 it
->font_height
= Qnil
;
2877 it
->override_ascent
= -1;
2879 /* Are control characters displayed as `^C'? */
2880 it
->ctl_arrow_p
= !NILP (BVAR (current_buffer
, ctl_arrow
));
2882 /* -1 means everything between a CR and the following line end
2883 is invisible. >0 means lines indented more than this value are
2885 it
->selective
= (INTEGERP (BVAR (current_buffer
, selective_display
))
2887 (-1, XINT (BVAR (current_buffer
, selective_display
)),
2889 : (!NILP (BVAR (current_buffer
, selective_display
))
2891 it
->selective_display_ellipsis_p
2892 = !NILP (BVAR (current_buffer
, selective_display_ellipses
));
2894 /* Display table to use. */
2895 it
->dp
= window_display_table (w
);
2897 /* Are multibyte characters enabled in current_buffer? */
2898 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
2900 /* Get the position at which the redisplay_end_trigger hook should
2901 be run, if it is to be run at all. */
2902 if (MARKERP (w
->redisplay_end_trigger
)
2903 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2904 it
->redisplay_end_trigger_charpos
2905 = marker_position (w
->redisplay_end_trigger
);
2906 else if (INTEGERP (w
->redisplay_end_trigger
))
2907 it
->redisplay_end_trigger_charpos
2908 = clip_to_bounds (PTRDIFF_MIN
, XINT (w
->redisplay_end_trigger
),
2911 it
->tab_width
= SANE_TAB_WIDTH (current_buffer
);
2913 /* Are lines in the display truncated? */
2914 if (base_face_id
!= DEFAULT_FACE_ID
2916 || (! WINDOW_FULL_WIDTH_P (it
->w
)
2917 && ((!NILP (Vtruncate_partial_width_windows
)
2918 && !INTEGERP (Vtruncate_partial_width_windows
))
2919 || (INTEGERP (Vtruncate_partial_width_windows
)
2920 /* PXW: Shall we do something about this? */
2921 && (WINDOW_TOTAL_COLS (it
->w
)
2922 < XINT (Vtruncate_partial_width_windows
))))))
2923 it
->line_wrap
= TRUNCATE
;
2924 else if (NILP (BVAR (current_buffer
, truncate_lines
)))
2925 it
->line_wrap
= NILP (BVAR (current_buffer
, word_wrap
))
2926 ? WINDOW_WRAP
: WORD_WRAP
;
2928 it
->line_wrap
= TRUNCATE
;
2930 /* Get dimensions of truncation and continuation glyphs. These are
2931 displayed as fringe bitmaps under X, but we need them for such
2932 frames when the fringes are turned off. But leave the dimensions
2933 zero for tooltip frames, as these glyphs look ugly there and also
2934 sabotage calculations of tooltip dimensions in x-show-tip. */
2935 #ifdef HAVE_WINDOW_SYSTEM
2936 if (!(FRAME_WINDOW_P (it
->f
)
2937 && FRAMEP (tip_frame
)
2938 && it
->f
== XFRAME (tip_frame
)))
2941 if (it
->line_wrap
== TRUNCATE
)
2943 /* We will need the truncation glyph. */
2944 eassert (it
->glyph_row
== NULL
);
2945 produce_special_glyphs (it
, IT_TRUNCATION
);
2946 it
->truncation_pixel_width
= it
->pixel_width
;
2950 /* We will need the continuation glyph. */
2951 eassert (it
->glyph_row
== NULL
);
2952 produce_special_glyphs (it
, IT_CONTINUATION
);
2953 it
->continuation_pixel_width
= it
->pixel_width
;
2957 /* Reset these values to zero because the produce_special_glyphs
2958 above has changed them. */
2959 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2960 it
->phys_ascent
= it
->phys_descent
= 0;
2962 /* Set this after getting the dimensions of truncation and
2963 continuation glyphs, so that we don't produce glyphs when calling
2964 produce_special_glyphs, above. */
2965 it
->glyph_row
= row
;
2966 it
->area
= TEXT_AREA
;
2968 /* Forget any previous info about this row being reversed. */
2970 it
->glyph_row
->reversed_p
= 0;
2972 /* Get the dimensions of the display area. The display area
2973 consists of the visible window area plus a horizontally scrolled
2974 part to the left of the window. All x-values are relative to the
2975 start of this total display area. */
2976 if (base_face_id
!= DEFAULT_FACE_ID
)
2978 /* Mode lines, menu bar in terminal frames. */
2979 it
->first_visible_x
= 0;
2980 it
->last_visible_x
= WINDOW_PIXEL_WIDTH (w
);
2985 = window_hscroll_limited (it
->w
, it
->f
) * FRAME_COLUMN_WIDTH (it
->f
);
2986 it
->last_visible_x
= (it
->first_visible_x
2987 + window_box_width (w
, TEXT_AREA
));
2989 /* If we truncate lines, leave room for the truncation glyph(s) at
2990 the right margin. Otherwise, leave room for the continuation
2991 glyph(s). Done only if the window has no fringes. Since we
2992 don't know at this point whether there will be any R2L lines in
2993 the window, we reserve space for truncation/continuation glyphs
2994 even if only one of the fringes is absent. */
2995 if (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
2996 || (it
->bidi_p
&& WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0))
2998 if (it
->line_wrap
== TRUNCATE
)
2999 it
->last_visible_x
-= it
->truncation_pixel_width
;
3001 it
->last_visible_x
-= it
->continuation_pixel_width
;
3004 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
3005 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
3008 /* Leave room for a border glyph. */
3009 if (!FRAME_WINDOW_P (it
->f
)
3010 && !WINDOW_RIGHTMOST_P (it
->w
))
3011 it
->last_visible_x
-= 1;
3013 it
->last_visible_y
= window_text_bottom_y (w
);
3015 /* For mode lines and alike, arrange for the first glyph having a
3016 left box line if the face specifies a box. */
3017 if (base_face_id
!= DEFAULT_FACE_ID
)
3021 it
->face_id
= remapped_base_face_id
;
3023 /* If we have a boxed mode line, make the first character appear
3024 with a left box line. */
3025 face
= FACE_FROM_ID (it
->f
, remapped_base_face_id
);
3026 if (face
&& face
->box
!= FACE_NO_BOX
)
3027 it
->start_of_box_run_p
= true;
3030 /* If a buffer position was specified, set the iterator there,
3031 getting overlays and face properties from that position. */
3032 if (charpos
>= BUF_BEG (current_buffer
))
3034 it
->end_charpos
= ZV
;
3035 eassert (charpos
== BYTE_TO_CHAR (bytepos
));
3036 IT_CHARPOS (*it
) = charpos
;
3037 IT_BYTEPOS (*it
) = bytepos
;
3039 /* We will rely on `reseat' to set this up properly, via
3040 handle_face_prop. */
3041 it
->face_id
= it
->base_face_id
;
3043 it
->start
= it
->current
;
3044 /* Do we need to reorder bidirectional text? Not if this is a
3045 unibyte buffer: by definition, none of the single-byte
3046 characters are strong R2L, so no reordering is needed. And
3047 bidi.c doesn't support unibyte buffers anyway. Also, don't
3048 reorder while we are loading loadup.el, since the tables of
3049 character properties needed for reordering are not yet
3053 && !NILP (BVAR (current_buffer
, bidi_display_reordering
))
3056 /* If we are to reorder bidirectional text, init the bidi
3060 /* Note the paragraph direction that this buffer wants to
3062 if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
3064 it
->paragraph_embedding
= L2R
;
3065 else if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
3067 it
->paragraph_embedding
= R2L
;
3069 it
->paragraph_embedding
= NEUTRAL_DIR
;
3070 bidi_unshelve_cache (NULL
, 0);
3071 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
3075 /* Compute faces etc. */
3076 reseat (it
, it
->current
.pos
, 1);
3083 /* Initialize IT for the display of window W with window start POS. */
3086 start_display (struct it
*it
, struct window
*w
, struct text_pos pos
)
3088 struct glyph_row
*row
;
3089 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
3091 row
= w
->desired_matrix
->rows
+ first_vpos
;
3092 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
3093 it
->first_vpos
= first_vpos
;
3095 /* Don't reseat to previous visible line start if current start
3096 position is in a string or image. */
3097 if (it
->method
== GET_FROM_BUFFER
&& it
->line_wrap
!= TRUNCATE
)
3099 int start_at_line_beg_p
;
3100 int first_y
= it
->current_y
;
3102 /* If window start is not at a line start, skip forward to POS to
3103 get the correct continuation lines width. */
3104 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
3105 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
3106 if (!start_at_line_beg_p
)
3110 reseat_at_previous_visible_line_start (it
);
3111 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
3113 new_x
= it
->current_x
+ it
->pixel_width
;
3115 /* If lines are continued, this line may end in the middle
3116 of a multi-glyph character (e.g. a control character
3117 displayed as \003, or in the middle of an overlay
3118 string). In this case move_it_to above will not have
3119 taken us to the start of the continuation line but to the
3120 end of the continued line. */
3121 if (it
->current_x
> 0
3122 && it
->line_wrap
!= TRUNCATE
/* Lines are continued. */
3123 && (/* And glyph doesn't fit on the line. */
3124 new_x
> it
->last_visible_x
3125 /* Or it fits exactly and we're on a window
3127 || (new_x
== it
->last_visible_x
3128 && FRAME_WINDOW_P (it
->f
)
3129 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
3130 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
3131 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
3133 if ((it
->current
.dpvec_index
>= 0
3134 || it
->current
.overlay_string_index
>= 0)
3135 /* If we are on a newline from a display vector or
3136 overlay string, then we are already at the end of
3137 a screen line; no need to go to the next line in
3138 that case, as this line is not really continued.
3139 (If we do go to the next line, C-e will not DTRT.) */
3142 set_iterator_to_next (it
, 1);
3143 move_it_in_display_line_to (it
, -1, -1, 0);
3146 it
->continuation_lines_width
+= it
->current_x
;
3148 /* If the character at POS is displayed via a display
3149 vector, move_it_to above stops at the final glyph of
3150 IT->dpvec. To make the caller redisplay that character
3151 again (a.k.a. start at POS), we need to reset the
3152 dpvec_index to the beginning of IT->dpvec. */
3153 else if (it
->current
.dpvec_index
>= 0)
3154 it
->current
.dpvec_index
= 0;
3156 /* We're starting a new display line, not affected by the
3157 height of the continued line, so clear the appropriate
3158 fields in the iterator structure. */
3159 it
->max_ascent
= it
->max_descent
= 0;
3160 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
3162 it
->current_y
= first_y
;
3164 it
->current_x
= it
->hpos
= 0;
3170 /* Return 1 if POS is a position in ellipses displayed for invisible
3171 text. W is the window we display, for text property lookup. */
3174 in_ellipses_for_invisible_text_p (struct display_pos
*pos
, struct window
*w
)
3176 Lisp_Object prop
, window
;
3178 ptrdiff_t charpos
= CHARPOS (pos
->pos
);
3180 /* If POS specifies a position in a display vector, this might
3181 be for an ellipsis displayed for invisible text. We won't
3182 get the iterator set up for delivering that ellipsis unless
3183 we make sure that it gets aware of the invisible text. */
3184 if (pos
->dpvec_index
>= 0
3185 && pos
->overlay_string_index
< 0
3186 && CHARPOS (pos
->string_pos
) < 0
3188 && (XSETWINDOW (window
, w
),
3189 prop
= Fget_char_property (make_number (charpos
),
3190 Qinvisible
, window
),
3191 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
3193 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
3195 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
3202 /* Initialize IT for stepping through current_buffer in window W,
3203 starting at position POS that includes overlay string and display
3204 vector/ control character translation position information. Value
3205 is zero if there are overlay strings with newlines at POS. */
3208 init_from_display_pos (struct it
*it
, struct window
*w
, struct display_pos
*pos
)
3210 ptrdiff_t charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
3211 int i
, overlay_strings_with_newlines
= 0;
3213 /* If POS specifies a position in a display vector, this might
3214 be for an ellipsis displayed for invisible text. We won't
3215 get the iterator set up for delivering that ellipsis unless
3216 we make sure that it gets aware of the invisible text. */
3217 if (in_ellipses_for_invisible_text_p (pos
, w
))
3223 /* Keep in mind: the call to reseat in init_iterator skips invisible
3224 text, so we might end up at a position different from POS. This
3225 is only a problem when POS is a row start after a newline and an
3226 overlay starts there with an after-string, and the overlay has an
3227 invisible property. Since we don't skip invisible text in
3228 display_line and elsewhere immediately after consuming the
3229 newline before the row start, such a POS will not be in a string,
3230 but the call to init_iterator below will move us to the
3232 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
3234 /* This only scans the current chunk -- it should scan all chunks.
3235 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
3236 to 16 in 22.1 to make this a lesser problem. */
3237 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
3239 const char *s
= SSDATA (it
->overlay_strings
[i
]);
3240 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
3242 while (s
< e
&& *s
!= '\n')
3247 overlay_strings_with_newlines
= 1;
3252 /* If position is within an overlay string, set up IT to the right
3254 if (pos
->overlay_string_index
>= 0)
3258 /* If the first overlay string happens to have a `display'
3259 property for an image, the iterator will be set up for that
3260 image, and we have to undo that setup first before we can
3261 correct the overlay string index. */
3262 if (it
->method
== GET_FROM_IMAGE
)
3265 /* We already have the first chunk of overlay strings in
3266 IT->overlay_strings. Load more until the one for
3267 pos->overlay_string_index is in IT->overlay_strings. */
3268 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
3270 ptrdiff_t n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
3271 it
->current
.overlay_string_index
= 0;
3274 load_overlay_strings (it
, 0);
3275 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
3279 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
3280 relative_index
= (it
->current
.overlay_string_index
3281 % OVERLAY_STRING_CHUNK_SIZE
);
3282 it
->string
= it
->overlay_strings
[relative_index
];
3283 eassert (STRINGP (it
->string
));
3284 it
->current
.string_pos
= pos
->string_pos
;
3285 it
->method
= GET_FROM_STRING
;
3286 it
->end_charpos
= SCHARS (it
->string
);
3287 /* Set up the bidi iterator for this overlay string. */
3290 it
->bidi_it
.string
.lstring
= it
->string
;
3291 it
->bidi_it
.string
.s
= NULL
;
3292 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
3293 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
3294 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
3295 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
3296 it
->bidi_it
.w
= it
->w
;
3297 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3298 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3300 /* Synchronize the state of the bidi iterator with
3301 pos->string_pos. For any string position other than
3302 zero, this will be done automagically when we resume
3303 iteration over the string and get_visually_first_element
3304 is called. But if string_pos is zero, and the string is
3305 to be reordered for display, we need to resync manually,
3306 since it could be that the iteration state recorded in
3307 pos ended at string_pos of 0 moving backwards in string. */
3308 if (CHARPOS (pos
->string_pos
) == 0)
3310 get_visually_first_element (it
);
3311 if (IT_STRING_CHARPOS (*it
) != 0)
3314 eassert (it
->bidi_it
.charpos
< it
->bidi_it
.string
.schars
);
3315 bidi_move_to_visually_next (&it
->bidi_it
);
3316 } while (it
->bidi_it
.charpos
!= 0);
3318 eassert (IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
3319 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
);
3323 if (CHARPOS (pos
->string_pos
) >= 0)
3325 /* Recorded position is not in an overlay string, but in another
3326 string. This can only be a string from a `display' property.
3327 IT should already be filled with that string. */
3328 it
->current
.string_pos
= pos
->string_pos
;
3329 eassert (STRINGP (it
->string
));
3331 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3332 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3335 /* Restore position in display vector translations, control
3336 character translations or ellipses. */
3337 if (pos
->dpvec_index
>= 0)
3339 if (it
->dpvec
== NULL
)
3340 get_next_display_element (it
);
3341 eassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
3342 it
->current
.dpvec_index
= pos
->dpvec_index
;
3346 return !overlay_strings_with_newlines
;
3350 /* Initialize IT for stepping through current_buffer in window W
3351 starting at ROW->start. */
3354 init_to_row_start (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3356 init_from_display_pos (it
, w
, &row
->start
);
3357 it
->start
= row
->start
;
3358 it
->continuation_lines_width
= row
->continuation_lines_width
;
3363 /* Initialize IT for stepping through current_buffer in window W
3364 starting in the line following ROW, i.e. starting at ROW->end.
3365 Value is zero if there are overlay strings with newlines at ROW's
3369 init_to_row_end (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3373 if (init_from_display_pos (it
, w
, &row
->end
))
3375 if (row
->continued_p
)
3376 it
->continuation_lines_width
3377 = row
->continuation_lines_width
+ row
->pixel_width
;
3388 /***********************************************************************
3390 ***********************************************************************/
3392 /* Called when IT reaches IT->stop_charpos. Handle text property and
3393 overlay changes. Set IT->stop_charpos to the next position where
3397 handle_stop (struct it
*it
)
3399 enum prop_handled handled
;
3400 int handle_overlay_change_p
;
3404 it
->current
.dpvec_index
= -1;
3405 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
3406 it
->ignore_overlay_strings_at_pos_p
= 0;
3409 /* Use face of preceding text for ellipsis (if invisible) */
3410 if (it
->selective_display_ellipsis_p
)
3411 it
->saved_face_id
= it
->face_id
;
3415 handled
= HANDLED_NORMALLY
;
3417 /* Call text property handlers. */
3418 for (p
= it_props
; p
->handler
; ++p
)
3420 handled
= p
->handler (it
);
3422 if (handled
== HANDLED_RECOMPUTE_PROPS
)
3424 else if (handled
== HANDLED_RETURN
)
3426 /* We still want to show before and after strings from
3427 overlays even if the actual buffer text is replaced. */
3428 if (!handle_overlay_change_p
3430 /* Don't call get_overlay_strings_1 if we already
3431 have overlay strings loaded, because doing so
3432 will load them again and push the iterator state
3433 onto the stack one more time, which is not
3434 expected by the rest of the code that processes
3436 || (it
->current
.overlay_string_index
< 0
3437 ? !get_overlay_strings_1 (it
, 0, 0)
3441 setup_for_ellipsis (it
, 0);
3442 /* When handling a display spec, we might load an
3443 empty string. In that case, discard it here. We
3444 used to discard it in handle_single_display_spec,
3445 but that causes get_overlay_strings_1, above, to
3446 ignore overlay strings that we must check. */
3447 if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3451 else if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3455 it
->ignore_overlay_strings_at_pos_p
= true;
3456 it
->string_from_display_prop_p
= 0;
3457 it
->from_disp_prop_p
= 0;
3458 handle_overlay_change_p
= 0;
3460 handled
= HANDLED_RECOMPUTE_PROPS
;
3463 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
3464 handle_overlay_change_p
= 0;
3467 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
3469 /* Don't check for overlay strings below when set to deliver
3470 characters from a display vector. */
3471 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
3472 handle_overlay_change_p
= 0;
3474 /* Handle overlay changes.
3475 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3476 if it finds overlays. */
3477 if (handle_overlay_change_p
)
3478 handled
= handle_overlay_change (it
);
3483 setup_for_ellipsis (it
, 0);
3487 while (handled
== HANDLED_RECOMPUTE_PROPS
);
3489 /* Determine where to stop next. */
3490 if (handled
== HANDLED_NORMALLY
)
3491 compute_stop_pos (it
);
3495 /* Compute IT->stop_charpos from text property and overlay change
3496 information for IT's current position. */
3499 compute_stop_pos (struct it
*it
)
3501 register INTERVAL iv
, next_iv
;
3502 Lisp_Object object
, limit
, position
;
3503 ptrdiff_t charpos
, bytepos
;
3505 if (STRINGP (it
->string
))
3507 /* Strings are usually short, so don't limit the search for
3509 it
->stop_charpos
= it
->end_charpos
;
3510 object
= it
->string
;
3512 charpos
= IT_STRING_CHARPOS (*it
);
3513 bytepos
= IT_STRING_BYTEPOS (*it
);
3519 /* If end_charpos is out of range for some reason, such as a
3520 misbehaving display function, rationalize it (Bug#5984). */
3521 if (it
->end_charpos
> ZV
)
3522 it
->end_charpos
= ZV
;
3523 it
->stop_charpos
= it
->end_charpos
;
3525 /* If next overlay change is in front of the current stop pos
3526 (which is IT->end_charpos), stop there. Note: value of
3527 next_overlay_change is point-max if no overlay change
3529 charpos
= IT_CHARPOS (*it
);
3530 bytepos
= IT_BYTEPOS (*it
);
3531 pos
= next_overlay_change (charpos
);
3532 if (pos
< it
->stop_charpos
)
3533 it
->stop_charpos
= pos
;
3535 /* Set up variables for computing the stop position from text
3536 property changes. */
3537 XSETBUFFER (object
, current_buffer
);
3538 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
3541 /* Get the interval containing IT's position. Value is a null
3542 interval if there isn't such an interval. */
3543 position
= make_number (charpos
);
3544 iv
= validate_interval_range (object
, &position
, &position
, 0);
3547 Lisp_Object values_here
[LAST_PROP_IDX
];
3550 /* Get properties here. */
3551 for (p
= it_props
; p
->handler
; ++p
)
3552 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3554 /* Look for an interval following iv that has different
3556 for (next_iv
= next_interval (iv
);
3559 || XFASTINT (limit
) > next_iv
->position
));
3560 next_iv
= next_interval (next_iv
))
3562 for (p
= it_props
; p
->handler
; ++p
)
3564 Lisp_Object new_value
;
3566 new_value
= textget (next_iv
->plist
, *p
->name
);
3567 if (!EQ (values_here
[p
->idx
], new_value
))
3577 if (INTEGERP (limit
)
3578 && next_iv
->position
>= XFASTINT (limit
))
3579 /* No text property change up to limit. */
3580 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3582 /* Text properties change in next_iv. */
3583 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3587 if (it
->cmp_it
.id
< 0)
3589 ptrdiff_t stoppos
= it
->end_charpos
;
3591 if (it
->bidi_p
&& it
->bidi_it
.scan_dir
< 0)
3593 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
,
3594 stoppos
, it
->string
);
3597 eassert (STRINGP (it
->string
)
3598 || (it
->stop_charpos
>= BEGV
3599 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3603 /* Return the position of the next overlay change after POS in
3604 current_buffer. Value is point-max if no overlay change
3605 follows. This is like `next-overlay-change' but doesn't use
3609 next_overlay_change (ptrdiff_t pos
)
3611 ptrdiff_t i
, noverlays
;
3613 Lisp_Object
*overlays
;
3615 /* Get all overlays at the given position. */
3616 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3618 /* If any of these overlays ends before endpos,
3619 use its ending point instead. */
3620 for (i
= 0; i
< noverlays
; ++i
)
3625 oend
= OVERLAY_END (overlays
[i
]);
3626 oendpos
= OVERLAY_POSITION (oend
);
3627 endpos
= min (endpos
, oendpos
);
3633 /* How many characters forward to search for a display property or
3634 display string. Searching too far forward makes the bidi display
3635 sluggish, especially in small windows. */
3636 #define MAX_DISP_SCAN 250
3638 /* Return the character position of a display string at or after
3639 position specified by POSITION. If no display string exists at or
3640 after POSITION, return ZV. A display string is either an overlay
3641 with `display' property whose value is a string, or a `display'
3642 text property whose value is a string. STRING is data about the
3643 string to iterate; if STRING->lstring is nil, we are iterating a
3644 buffer. FRAME_WINDOW_P is non-zero when we are displaying a window
3645 on a GUI frame. DISP_PROP is set to zero if we searched
3646 MAX_DISP_SCAN characters forward without finding any display
3647 strings, non-zero otherwise. It is set to 2 if the display string
3648 uses any kind of `(space ...)' spec that will produce a stretch of
3649 white space in the text area. */
3651 compute_display_string_pos (struct text_pos
*position
,
3652 struct bidi_string_data
*string
,
3654 int frame_window_p
, int *disp_prop
)
3656 /* OBJECT = nil means current buffer. */
3657 Lisp_Object object
, object1
;
3658 Lisp_Object pos
, spec
, limpos
;
3659 int string_p
= (string
&& (STRINGP (string
->lstring
) || string
->s
));
3660 ptrdiff_t eob
= string_p
? string
->schars
: ZV
;
3661 ptrdiff_t begb
= string_p
? 0 : BEGV
;
3662 ptrdiff_t bufpos
, charpos
= CHARPOS (*position
);
3664 (charpos
< eob
- MAX_DISP_SCAN
) ? charpos
+ MAX_DISP_SCAN
: eob
;
3665 struct text_pos tpos
;
3668 if (string
&& STRINGP (string
->lstring
))
3669 object1
= object
= string
->lstring
;
3670 else if (w
&& !string_p
)
3672 XSETWINDOW (object
, w
);
3676 object1
= object
= Qnil
;
3681 /* We don't support display properties whose values are strings
3682 that have display string properties. */
3683 || string
->from_disp_str
3684 /* C strings cannot have display properties. */
3685 || (string
->s
&& !STRINGP (object
)))
3691 /* If the character at CHARPOS is where the display string begins,
3693 pos
= make_number (charpos
);
3694 if (STRINGP (object
))
3695 bufpos
= string
->bufpos
;
3699 if (!NILP (spec
= Fget_char_property (pos
, Qdisplay
, object
))
3701 || !EQ (Fget_char_property (make_number (charpos
- 1), Qdisplay
,
3704 && (rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
, bufpos
,
3712 /* Look forward for the first character with a `display' property
3713 that will replace the underlying text when displayed. */
3714 limpos
= make_number (lim
);
3716 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object1
, limpos
);
3717 CHARPOS (tpos
) = XFASTINT (pos
);
3718 if (CHARPOS (tpos
) >= lim
)
3723 if (STRINGP (object
))
3724 BYTEPOS (tpos
) = string_char_to_byte (object
, CHARPOS (tpos
));
3726 BYTEPOS (tpos
) = CHAR_TO_BYTE (CHARPOS (tpos
));
3727 spec
= Fget_char_property (pos
, Qdisplay
, object
);
3728 if (!STRINGP (object
))
3729 bufpos
= CHARPOS (tpos
);
3730 } while (NILP (spec
)
3731 || !(rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
,
3732 bufpos
, frame_window_p
)));
3736 return CHARPOS (tpos
);
3739 /* Return the character position of the end of the display string that
3740 started at CHARPOS. If there's no display string at CHARPOS,
3741 return -1. A display string is either an overlay with `display'
3742 property whose value is a string or a `display' text property whose
3743 value is a string. */
3745 compute_display_string_end (ptrdiff_t charpos
, struct bidi_string_data
*string
)
3747 /* OBJECT = nil means current buffer. */
3748 Lisp_Object object
=
3749 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3750 Lisp_Object pos
= make_number (charpos
);
3752 (STRINGP (object
) || (string
&& string
->s
)) ? string
->schars
: ZV
;
3754 if (charpos
>= eob
|| (string
->s
&& !STRINGP (object
)))
3757 /* It could happen that the display property or overlay was removed
3758 since we found it in compute_display_string_pos above. One way
3759 this can happen is if JIT font-lock was called (through
3760 handle_fontified_prop), and jit-lock-functions remove text
3761 properties or overlays from the portion of buffer that includes
3762 CHARPOS. Muse mode is known to do that, for example. In this
3763 case, we return -1 to the caller, to signal that no display
3764 string is actually present at CHARPOS. See bidi_fetch_char for
3765 how this is handled.
3767 An alternative would be to never look for display properties past
3768 it->stop_charpos. But neither compute_display_string_pos nor
3769 bidi_fetch_char that calls it know or care where the next
3771 if (NILP (Fget_char_property (pos
, Qdisplay
, object
)))
3774 /* Look forward for the first character where the `display' property
3776 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3778 return XFASTINT (pos
);
3783 /***********************************************************************
3785 ***********************************************************************/
3787 /* Handle changes in the `fontified' property of the current buffer by
3788 calling hook functions from Qfontification_functions to fontify
3791 static enum prop_handled
3792 handle_fontified_prop (struct it
*it
)
3794 Lisp_Object prop
, pos
;
3795 enum prop_handled handled
= HANDLED_NORMALLY
;
3797 if (!NILP (Vmemory_full
))
3800 /* Get the value of the `fontified' property at IT's current buffer
3801 position. (The `fontified' property doesn't have a special
3802 meaning in strings.) If the value is nil, call functions from
3803 Qfontification_functions. */
3804 if (!STRINGP (it
->string
)
3806 && !NILP (Vfontification_functions
)
3807 && !NILP (Vrun_hooks
)
3808 && (pos
= make_number (IT_CHARPOS (*it
)),
3809 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3810 /* Ignore the special cased nil value always present at EOB since
3811 no amount of fontifying will be able to change it. */
3812 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3814 ptrdiff_t count
= SPECPDL_INDEX ();
3816 struct buffer
*obuf
= current_buffer
;
3817 ptrdiff_t begv
= BEGV
, zv
= ZV
;
3818 bool old_clip_changed
= current_buffer
->clip_changed
;
3820 val
= Vfontification_functions
;
3821 specbind (Qfontification_functions
, Qnil
);
3823 eassert (it
->end_charpos
== ZV
);
3825 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3826 safe_call1 (val
, pos
);
3829 Lisp_Object fns
, fn
;
3830 struct gcpro gcpro1
, gcpro2
;
3835 for (; CONSP (val
); val
= XCDR (val
))
3841 /* A value of t indicates this hook has a local
3842 binding; it means to run the global binding too.
3843 In a global value, t should not occur. If it
3844 does, we must ignore it to avoid an endless
3846 for (fns
= Fdefault_value (Qfontification_functions
);
3852 safe_call1 (fn
, pos
);
3856 safe_call1 (fn
, pos
);
3862 unbind_to (count
, Qnil
);
3864 /* Fontification functions routinely call `save-restriction'.
3865 Normally, this tags clip_changed, which can confuse redisplay
3866 (see discussion in Bug#6671). Since we don't perform any
3867 special handling of fontification changes in the case where
3868 `save-restriction' isn't called, there's no point doing so in
3869 this case either. So, if the buffer's restrictions are
3870 actually left unchanged, reset clip_changed. */
3871 if (obuf
== current_buffer
)
3873 if (begv
== BEGV
&& zv
== ZV
)
3874 current_buffer
->clip_changed
= old_clip_changed
;
3876 /* There isn't much we can reasonably do to protect against
3877 misbehaving fontification, but here's a fig leaf. */
3878 else if (BUFFER_LIVE_P (obuf
))
3879 set_buffer_internal_1 (obuf
);
3881 /* The fontification code may have added/removed text.
3882 It could do even a lot worse, but let's at least protect against
3883 the most obvious case where only the text past `pos' gets changed',
3884 as is/was done in grep.el where some escapes sequences are turned
3885 into face properties (bug#7876). */
3886 it
->end_charpos
= ZV
;
3888 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3889 something. This avoids an endless loop if they failed to
3890 fontify the text for which reason ever. */
3891 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3892 handled
= HANDLED_RECOMPUTE_PROPS
;
3900 /***********************************************************************
3902 ***********************************************************************/
3904 /* Set up iterator IT from face properties at its current position.
3905 Called from handle_stop. */
3907 static enum prop_handled
3908 handle_face_prop (struct it
*it
)
3911 ptrdiff_t next_stop
;
3913 if (!STRINGP (it
->string
))
3916 = face_at_buffer_position (it
->w
,
3920 + TEXT_PROP_DISTANCE_LIMIT
),
3921 0, it
->base_face_id
);
3923 /* Is this a start of a run of characters with box face?
3924 Caveat: this can be called for a freshly initialized
3925 iterator; face_id is -1 in this case. We know that the new
3926 face will not change until limit, i.e. if the new face has a
3927 box, all characters up to limit will have one. But, as
3928 usual, we don't know whether limit is really the end. */
3929 if (new_face_id
!= it
->face_id
)
3931 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3932 /* If it->face_id is -1, old_face below will be NULL, see
3933 the definition of FACE_FROM_ID. This will happen if this
3934 is the initial call that gets the face. */
3935 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3937 /* If the value of face_id of the iterator is -1, we have to
3938 look in front of IT's position and see whether there is a
3939 face there that's different from new_face_id. */
3940 if (!old_face
&& IT_CHARPOS (*it
) > BEG
)
3942 int prev_face_id
= face_before_it_pos (it
);
3944 old_face
= FACE_FROM_ID (it
->f
, prev_face_id
);
3947 /* If the new face has a box, but the old face does not,
3948 this is the start of a run of characters with box face,
3949 i.e. this character has a shadow on the left side. */
3950 it
->start_of_box_run_p
= (new_face
->box
!= FACE_NO_BOX
3951 && (old_face
== NULL
|| !old_face
->box
));
3952 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3960 Lisp_Object from_overlay
3961 = (it
->current
.overlay_string_index
>= 0
3962 ? it
->string_overlays
[it
->current
.overlay_string_index
3963 % OVERLAY_STRING_CHUNK_SIZE
]
3966 /* See if we got to this string directly or indirectly from
3967 an overlay property. That includes the before-string or
3968 after-string of an overlay, strings in display properties
3969 provided by an overlay, their text properties, etc.
3971 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3972 if (! NILP (from_overlay
))
3973 for (i
= it
->sp
- 1; i
>= 0; i
--)
3975 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3977 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
3978 % OVERLAY_STRING_CHUNK_SIZE
];
3979 else if (! NILP (it
->stack
[i
].from_overlay
))
3980 from_overlay
= it
->stack
[i
].from_overlay
;
3982 if (!NILP (from_overlay
))
3986 if (! NILP (from_overlay
))
3988 bufpos
= IT_CHARPOS (*it
);
3989 /* For a string from an overlay, the base face depends
3990 only on text properties and ignores overlays. */
3992 = face_for_overlay_string (it
->w
,
3996 + TEXT_PROP_DISTANCE_LIMIT
),
4004 /* For strings from a `display' property, use the face at
4005 IT's current buffer position as the base face to merge
4006 with, so that overlay strings appear in the same face as
4007 surrounding text, unless they specify their own faces.
4008 For strings from wrap-prefix and line-prefix properties,
4009 use the default face, possibly remapped via
4010 Vface_remapping_alist. */
4011 /* Note that the fact that we use the face at _buffer_
4012 position means that a 'display' property on an overlay
4013 string will not inherit the face of that overlay string,
4014 but will instead revert to the face of buffer text
4015 covered by the overlay. This is visible, e.g., when the
4016 overlay specifies a box face, but neither the buffer nor
4017 the display string do. This sounds like a design bug,
4018 but Emacs always did that since v21.1, so changing that
4019 might be a big deal. */
4020 base_face_id
= it
->string_from_prefix_prop_p
4021 ? (!NILP (Vface_remapping_alist
)
4022 ? lookup_basic_face (it
->f
, DEFAULT_FACE_ID
)
4024 : underlying_face_id (it
);
4027 new_face_id
= face_at_string_position (it
->w
,
4029 IT_STRING_CHARPOS (*it
),
4034 /* Is this a start of a run of characters with box? Caveat:
4035 this can be called for a freshly allocated iterator; face_id
4036 is -1 is this case. We know that the new face will not
4037 change until the next check pos, i.e. if the new face has a
4038 box, all characters up to that position will have a
4039 box. But, as usual, we don't know whether that position
4040 is really the end. */
4041 if (new_face_id
!= it
->face_id
)
4043 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
4044 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4046 /* If new face has a box but old face hasn't, this is the
4047 start of a run of characters with box, i.e. it has a
4048 shadow on the left side. */
4049 it
->start_of_box_run_p
4050 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
4051 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
4055 it
->face_id
= new_face_id
;
4056 return HANDLED_NORMALLY
;
4060 /* Return the ID of the face ``underlying'' IT's current position,
4061 which is in a string. If the iterator is associated with a
4062 buffer, return the face at IT's current buffer position.
4063 Otherwise, use the iterator's base_face_id. */
4066 underlying_face_id (struct it
*it
)
4068 int face_id
= it
->base_face_id
, i
;
4070 eassert (STRINGP (it
->string
));
4072 for (i
= it
->sp
- 1; i
>= 0; --i
)
4073 if (NILP (it
->stack
[i
].string
))
4074 face_id
= it
->stack
[i
].face_id
;
4080 /* Compute the face one character before or after the current position
4081 of IT, in the visual order. BEFORE_P non-zero means get the face
4082 in front (to the left in L2R paragraphs, to the right in R2L
4083 paragraphs) of IT's screen position. Value is the ID of the face. */
4086 face_before_or_after_it_pos (struct it
*it
, int before_p
)
4089 ptrdiff_t next_check_charpos
;
4091 void *it_copy_data
= NULL
;
4093 eassert (it
->s
== NULL
);
4095 if (STRINGP (it
->string
))
4097 ptrdiff_t bufpos
, charpos
;
4100 /* No face change past the end of the string (for the case
4101 we are padding with spaces). No face change before the
4103 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
4104 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
4109 /* Set charpos to the position before or after IT's current
4110 position, in the logical order, which in the non-bidi
4111 case is the same as the visual order. */
4113 charpos
= IT_STRING_CHARPOS (*it
) - 1;
4114 else if (it
->what
== IT_COMPOSITION
)
4115 /* For composition, we must check the character after the
4117 charpos
= IT_STRING_CHARPOS (*it
) + it
->cmp_it
.nchars
;
4119 charpos
= IT_STRING_CHARPOS (*it
) + 1;
4125 /* With bidi iteration, the character before the current
4126 in the visual order cannot be found by simple
4127 iteration, because "reverse" reordering is not
4128 supported. Instead, we need to use the move_it_*
4129 family of functions. */
4130 /* Ignore face changes before the first visible
4131 character on this display line. */
4132 if (it
->current_x
<= it
->first_visible_x
)
4134 SAVE_IT (it_copy
, *it
, it_copy_data
);
4135 /* Implementation note: Since move_it_in_display_line
4136 works in the iterator geometry, and thinks the first
4137 character is always the leftmost, even in R2L lines,
4138 we don't need to distinguish between the R2L and L2R
4140 move_it_in_display_line (&it_copy
, SCHARS (it_copy
.string
),
4141 it_copy
.current_x
- 1, MOVE_TO_X
);
4142 charpos
= IT_STRING_CHARPOS (it_copy
);
4143 RESTORE_IT (it
, it
, it_copy_data
);
4147 /* Set charpos to the string position of the character
4148 that comes after IT's current position in the visual
4150 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
4154 bidi_move_to_visually_next (&it_copy
.bidi_it
);
4156 charpos
= it_copy
.bidi_it
.charpos
;
4159 eassert (0 <= charpos
&& charpos
<= SCHARS (it
->string
));
4161 if (it
->current
.overlay_string_index
>= 0)
4162 bufpos
= IT_CHARPOS (*it
);
4166 base_face_id
= underlying_face_id (it
);
4168 /* Get the face for ASCII, or unibyte. */
4169 face_id
= face_at_string_position (it
->w
,
4173 &next_check_charpos
,
4176 /* Correct the face for charsets different from ASCII. Do it
4177 for the multibyte case only. The face returned above is
4178 suitable for unibyte text if IT->string is unibyte. */
4179 if (STRING_MULTIBYTE (it
->string
))
4181 struct text_pos pos1
= string_pos (charpos
, it
->string
);
4182 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos1
);
4184 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
4186 c
= string_char_and_length (p
, &len
);
4187 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, charpos
, it
->string
);
4192 struct text_pos pos
;
4194 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
4195 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
4198 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
4199 pos
= it
->current
.pos
;
4204 DEC_TEXT_POS (pos
, it
->multibyte_p
);
4207 if (it
->what
== IT_COMPOSITION
)
4209 /* For composition, we must check the position after
4211 pos
.charpos
+= it
->cmp_it
.nchars
;
4212 pos
.bytepos
+= it
->len
;
4215 INC_TEXT_POS (pos
, it
->multibyte_p
);
4222 /* With bidi iteration, the character before the current
4223 in the visual order cannot be found by simple
4224 iteration, because "reverse" reordering is not
4225 supported. Instead, we need to use the move_it_*
4226 family of functions. */
4227 /* Ignore face changes before the first visible
4228 character on this display line. */
4229 if (it
->current_x
<= it
->first_visible_x
)
4231 SAVE_IT (it_copy
, *it
, it_copy_data
);
4232 /* Implementation note: Since move_it_in_display_line
4233 works in the iterator geometry, and thinks the first
4234 character is always the leftmost, even in R2L lines,
4235 we don't need to distinguish between the R2L and L2R
4237 move_it_in_display_line (&it_copy
, ZV
,
4238 it_copy
.current_x
- 1, MOVE_TO_X
);
4239 pos
= it_copy
.current
.pos
;
4240 RESTORE_IT (it
, it
, it_copy_data
);
4244 /* Set charpos to the buffer position of the character
4245 that comes after IT's current position in the visual
4247 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
4251 bidi_move_to_visually_next (&it_copy
.bidi_it
);
4254 it_copy
.bidi_it
.charpos
, it_copy
.bidi_it
.bytepos
);
4257 eassert (BEGV
<= CHARPOS (pos
) && CHARPOS (pos
) <= ZV
);
4259 /* Determine face for CHARSET_ASCII, or unibyte. */
4260 face_id
= face_at_buffer_position (it
->w
,
4262 &next_check_charpos
,
4265 /* Correct the face for charsets different from ASCII. Do it
4266 for the multibyte case only. The face returned above is
4267 suitable for unibyte text if current_buffer is unibyte. */
4268 if (it
->multibyte_p
)
4270 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
4271 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
4272 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
4281 /***********************************************************************
4283 ***********************************************************************/
4285 /* Set up iterator IT from invisible properties at its current
4286 position. Called from handle_stop. */
4288 static enum prop_handled
4289 handle_invisible_prop (struct it
*it
)
4291 enum prop_handled handled
= HANDLED_NORMALLY
;
4295 if (STRINGP (it
->string
))
4297 Lisp_Object end_charpos
, limit
, charpos
;
4299 /* Get the value of the invisible text property at the
4300 current position. Value will be nil if there is no such
4302 charpos
= make_number (IT_STRING_CHARPOS (*it
));
4303 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
4304 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4306 if (invis_p
&& IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
4308 /* Record whether we have to display an ellipsis for the
4310 int display_ellipsis_p
= (invis_p
== 2);
4311 ptrdiff_t len
, endpos
;
4313 handled
= HANDLED_RECOMPUTE_PROPS
;
4315 /* Get the position at which the next visible text can be
4316 found in IT->string, if any. */
4317 endpos
= len
= SCHARS (it
->string
);
4318 XSETINT (limit
, len
);
4321 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
4323 if (INTEGERP (end_charpos
))
4325 endpos
= XFASTINT (end_charpos
);
4326 prop
= Fget_text_property (end_charpos
, Qinvisible
, it
->string
);
4327 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4329 display_ellipsis_p
= true;
4332 while (invis_p
&& endpos
< len
);
4334 if (display_ellipsis_p
)
4335 it
->ellipsis_p
= true;
4339 /* Text at END_CHARPOS is visible. Move IT there. */
4340 struct text_pos old
;
4343 old
= it
->current
.string_pos
;
4344 oldpos
= CHARPOS (old
);
4347 if (it
->bidi_it
.first_elt
4348 && it
->bidi_it
.charpos
< SCHARS (it
->string
))
4349 bidi_paragraph_init (it
->paragraph_embedding
,
4351 /* Bidi-iterate out of the invisible text. */
4354 bidi_move_to_visually_next (&it
->bidi_it
);
4356 while (oldpos
<= it
->bidi_it
.charpos
4357 && it
->bidi_it
.charpos
< endpos
);
4359 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4360 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4361 if (IT_CHARPOS (*it
) >= endpos
)
4362 it
->prev_stop
= endpos
;
4366 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
4367 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
4372 /* The rest of the string is invisible. If this is an
4373 overlay string, proceed with the next overlay string
4374 or whatever comes and return a character from there. */
4375 if (it
->current
.overlay_string_index
>= 0
4376 && !display_ellipsis_p
)
4378 next_overlay_string (it
);
4379 /* Don't check for overlay strings when we just
4380 finished processing them. */
4381 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
4385 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
4386 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
4393 ptrdiff_t newpos
, next_stop
, start_charpos
, tem
;
4394 Lisp_Object pos
, overlay
;
4396 /* First of all, is there invisible text at this position? */
4397 tem
= start_charpos
= IT_CHARPOS (*it
);
4398 pos
= make_number (tem
);
4399 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
4401 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4403 /* If we are on invisible text, skip over it. */
4404 if (invis_p
&& start_charpos
< it
->end_charpos
)
4406 /* Record whether we have to display an ellipsis for the
4408 int display_ellipsis_p
= invis_p
== 2;
4410 handled
= HANDLED_RECOMPUTE_PROPS
;
4412 /* Loop skipping over invisible text. The loop is left at
4413 ZV or with IT on the first char being visible again. */
4416 /* Try to skip some invisible text. Return value is the
4417 position reached which can be equal to where we start
4418 if there is nothing invisible there. This skips both
4419 over invisible text properties and overlays with
4420 invisible property. */
4421 newpos
= skip_invisible (tem
, &next_stop
, ZV
, it
->window
);
4423 /* If we skipped nothing at all we weren't at invisible
4424 text in the first place. If everything to the end of
4425 the buffer was skipped, end the loop. */
4426 if (newpos
== tem
|| newpos
>= ZV
)
4430 /* We skipped some characters but not necessarily
4431 all there are. Check if we ended up on visible
4432 text. Fget_char_property returns the property of
4433 the char before the given position, i.e. if we
4434 get invis_p = 0, this means that the char at
4435 newpos is visible. */
4436 pos
= make_number (newpos
);
4437 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
4438 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4441 /* If we ended up on invisible text, proceed to
4442 skip starting with next_stop. */
4446 /* If there are adjacent invisible texts, don't lose the
4447 second one's ellipsis. */
4449 display_ellipsis_p
= true;
4453 /* The position newpos is now either ZV or on visible text. */
4456 ptrdiff_t bpos
= CHAR_TO_BYTE (newpos
);
4458 = bpos
== ZV_BYTE
|| FETCH_BYTE (bpos
) == '\n';
4460 = newpos
<= BEGV
|| FETCH_BYTE (bpos
- 1) == '\n';
4462 /* If the invisible text ends on a newline or on a
4463 character after a newline, we can avoid the costly,
4464 character by character, bidi iteration to NEWPOS, and
4465 instead simply reseat the iterator there. That's
4466 because all bidi reordering information is tossed at
4467 the newline. This is a big win for modes that hide
4468 complete lines, like Outline, Org, etc. */
4469 if (on_newline
|| after_newline
)
4471 struct text_pos tpos
;
4472 bidi_dir_t pdir
= it
->bidi_it
.paragraph_dir
;
4474 SET_TEXT_POS (tpos
, newpos
, bpos
);
4475 reseat_1 (it
, tpos
, 0);
4476 /* If we reseat on a newline/ZV, we need to prep the
4477 bidi iterator for advancing to the next character
4478 after the newline/EOB, keeping the current paragraph
4479 direction (so that PRODUCE_GLYPHS does TRT wrt
4480 prepending/appending glyphs to a glyph row). */
4483 it
->bidi_it
.first_elt
= 0;
4484 it
->bidi_it
.paragraph_dir
= pdir
;
4485 it
->bidi_it
.ch
= (bpos
== ZV_BYTE
) ? -1 : '\n';
4486 it
->bidi_it
.nchars
= 1;
4487 it
->bidi_it
.ch_len
= 1;
4490 else /* Must use the slow method. */
4492 /* With bidi iteration, the region of invisible text
4493 could start and/or end in the middle of a
4494 non-base embedding level. Therefore, we need to
4495 skip invisible text using the bidi iterator,
4496 starting at IT's current position, until we find
4497 ourselves outside of the invisible text.
4498 Skipping invisible text _after_ bidi iteration
4499 avoids affecting the visual order of the
4500 displayed text when invisible properties are
4501 added or removed. */
4502 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
4504 /* If we were `reseat'ed to a new paragraph,
4505 determine the paragraph base direction. We
4506 need to do it now because
4507 next_element_from_buffer may not have a
4508 chance to do it, if we are going to skip any
4509 text at the beginning, which resets the
4511 bidi_paragraph_init (it
->paragraph_embedding
,
4516 bidi_move_to_visually_next (&it
->bidi_it
);
4518 while (it
->stop_charpos
<= it
->bidi_it
.charpos
4519 && it
->bidi_it
.charpos
< newpos
);
4520 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4521 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4522 /* If we overstepped NEWPOS, record its position in
4523 the iterator, so that we skip invisible text if
4524 later the bidi iteration lands us in the
4525 invisible region again. */
4526 if (IT_CHARPOS (*it
) >= newpos
)
4527 it
->prev_stop
= newpos
;
4532 IT_CHARPOS (*it
) = newpos
;
4533 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
4536 /* If there are before-strings at the start of invisible
4537 text, and the text is invisible because of a text
4538 property, arrange to show before-strings because 20.x did
4539 it that way. (If the text is invisible because of an
4540 overlay property instead of a text property, this is
4541 already handled in the overlay code.) */
4543 && get_overlay_strings (it
, it
->stop_charpos
))
4545 handled
= HANDLED_RECOMPUTE_PROPS
;
4546 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
4548 else if (display_ellipsis_p
)
4550 /* Make sure that the glyphs of the ellipsis will get
4551 correct `charpos' values. If we would not update
4552 it->position here, the glyphs would belong to the
4553 last visible character _before_ the invisible
4554 text, which confuses `set_cursor_from_row'.
4556 We use the last invisible position instead of the
4557 first because this way the cursor is always drawn on
4558 the first "." of the ellipsis, whenever PT is inside
4559 the invisible text. Otherwise the cursor would be
4560 placed _after_ the ellipsis when the point is after the
4561 first invisible character. */
4562 if (!STRINGP (it
->object
))
4564 it
->position
.charpos
= newpos
- 1;
4565 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
4567 it
->ellipsis_p
= true;
4568 /* Let the ellipsis display before
4569 considering any properties of the following char.
4570 Fixes jasonr@gnu.org 01 Oct 07 bug. */
4571 handled
= HANDLED_RETURN
;
4580 /* Make iterator IT return `...' next.
4581 Replaces LEN characters from buffer. */
4584 setup_for_ellipsis (struct it
*it
, int len
)
4586 /* Use the display table definition for `...'. Invalid glyphs
4587 will be handled by the method returning elements from dpvec. */
4588 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4590 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4591 it
->dpvec
= v
->contents
;
4592 it
->dpend
= v
->contents
+ v
->header
.size
;
4596 /* Default `...'. */
4597 it
->dpvec
= default_invis_vector
;
4598 it
->dpend
= default_invis_vector
+ 3;
4601 it
->dpvec_char_len
= len
;
4602 it
->current
.dpvec_index
= 0;
4603 it
->dpvec_face_id
= -1;
4605 /* Remember the current face id in case glyphs specify faces.
4606 IT's face is restored in set_iterator_to_next.
4607 saved_face_id was set to preceding char's face in handle_stop. */
4608 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
4609 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
4611 it
->method
= GET_FROM_DISPLAY_VECTOR
;
4612 it
->ellipsis_p
= true;
4617 /***********************************************************************
4619 ***********************************************************************/
4621 /* Set up iterator IT from `display' property at its current position.
4622 Called from handle_stop.
4623 We return HANDLED_RETURN if some part of the display property
4624 overrides the display of the buffer text itself.
4625 Otherwise we return HANDLED_NORMALLY. */
4627 static enum prop_handled
4628 handle_display_prop (struct it
*it
)
4630 Lisp_Object propval
, object
, overlay
;
4631 struct text_pos
*position
;
4633 /* Nonzero if some property replaces the display of the text itself. */
4634 int display_replaced_p
= 0;
4636 if (STRINGP (it
->string
))
4638 object
= it
->string
;
4639 position
= &it
->current
.string_pos
;
4640 bufpos
= CHARPOS (it
->current
.pos
);
4644 XSETWINDOW (object
, it
->w
);
4645 position
= &it
->current
.pos
;
4646 bufpos
= CHARPOS (*position
);
4649 /* Reset those iterator values set from display property values. */
4650 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
4651 it
->space_width
= Qnil
;
4652 it
->font_height
= Qnil
;
4655 /* We don't support recursive `display' properties, i.e. string
4656 values that have a string `display' property, that have a string
4657 `display' property etc. */
4658 if (!it
->string_from_display_prop_p
)
4659 it
->area
= TEXT_AREA
;
4661 propval
= get_char_property_and_overlay (make_number (position
->charpos
),
4662 Qdisplay
, object
, &overlay
);
4664 return HANDLED_NORMALLY
;
4665 /* Now OVERLAY is the overlay that gave us this property, or nil
4666 if it was a text property. */
4668 if (!STRINGP (it
->string
))
4669 object
= it
->w
->contents
;
4671 display_replaced_p
= handle_display_spec (it
, propval
, object
, overlay
,
4673 FRAME_WINDOW_P (it
->f
));
4675 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
4678 /* Subroutine of handle_display_prop. Returns non-zero if the display
4679 specification in SPEC is a replacing specification, i.e. it would
4680 replace the text covered by `display' property with something else,
4681 such as an image or a display string. If SPEC includes any kind or
4682 `(space ...) specification, the value is 2; this is used by
4683 compute_display_string_pos, which see.
4685 See handle_single_display_spec for documentation of arguments.
4686 frame_window_p is non-zero if the window being redisplayed is on a
4687 GUI frame; this argument is used only if IT is NULL, see below.
4689 IT can be NULL, if this is called by the bidi reordering code
4690 through compute_display_string_pos, which see. In that case, this
4691 function only examines SPEC, but does not otherwise "handle" it, in
4692 the sense that it doesn't set up members of IT from the display
4695 handle_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4696 Lisp_Object overlay
, struct text_pos
*position
,
4697 ptrdiff_t bufpos
, int frame_window_p
)
4699 int replacing_p
= 0;
4703 /* Simple specifications. */
4704 && !EQ (XCAR (spec
), Qimage
)
4705 && !EQ (XCAR (spec
), Qspace
)
4706 && !EQ (XCAR (spec
), Qwhen
)
4707 && !EQ (XCAR (spec
), Qslice
)
4708 && !EQ (XCAR (spec
), Qspace_width
)
4709 && !EQ (XCAR (spec
), Qheight
)
4710 && !EQ (XCAR (spec
), Qraise
)
4711 /* Marginal area specifications. */
4712 && !(CONSP (XCAR (spec
)) && EQ (XCAR (XCAR (spec
)), Qmargin
))
4713 && !EQ (XCAR (spec
), Qleft_fringe
)
4714 && !EQ (XCAR (spec
), Qright_fringe
)
4715 && !NILP (XCAR (spec
)))
4717 for (; CONSP (spec
); spec
= XCDR (spec
))
4719 if ((rv
= handle_single_display_spec (it
, XCAR (spec
), object
,
4720 overlay
, position
, bufpos
,
4721 replacing_p
, frame_window_p
)))
4724 /* If some text in a string is replaced, `position' no
4725 longer points to the position of `object'. */
4726 if (!it
|| STRINGP (object
))
4731 else if (VECTORP (spec
))
4734 for (i
= 0; i
< ASIZE (spec
); ++i
)
4735 if ((rv
= handle_single_display_spec (it
, AREF (spec
, i
), object
,
4736 overlay
, position
, bufpos
,
4737 replacing_p
, frame_window_p
)))
4740 /* If some text in a string is replaced, `position' no
4741 longer points to the position of `object'. */
4742 if (!it
|| STRINGP (object
))
4748 if ((rv
= handle_single_display_spec (it
, spec
, object
, overlay
,
4749 position
, bufpos
, 0,
4757 /* Value is the position of the end of the `display' property starting
4758 at START_POS in OBJECT. */
4760 static struct text_pos
4761 display_prop_end (struct it
*it
, Lisp_Object object
, struct text_pos start_pos
)
4764 struct text_pos end_pos
;
4766 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
4767 Qdisplay
, object
, Qnil
);
4768 CHARPOS (end_pos
) = XFASTINT (end
);
4769 if (STRINGP (object
))
4770 compute_string_pos (&end_pos
, start_pos
, it
->string
);
4772 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
4778 /* Set up IT from a single `display' property specification SPEC. OBJECT
4779 is the object in which the `display' property was found. *POSITION
4780 is the position in OBJECT at which the `display' property was found.
4781 BUFPOS is the buffer position of OBJECT (different from POSITION if
4782 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
4783 previously saw a display specification which already replaced text
4784 display with something else, for example an image; we ignore such
4785 properties after the first one has been processed.
4787 OVERLAY is the overlay this `display' property came from,
4788 or nil if it was a text property.
4790 If SPEC is a `space' or `image' specification, and in some other
4791 cases too, set *POSITION to the position where the `display'
4794 If IT is NULL, only examine the property specification in SPEC, but
4795 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
4796 is intended to be displayed in a window on a GUI frame.
4798 Value is non-zero if something was found which replaces the display
4799 of buffer or string text. */
4802 handle_single_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4803 Lisp_Object overlay
, struct text_pos
*position
,
4804 ptrdiff_t bufpos
, int display_replaced_p
,
4808 Lisp_Object location
, value
;
4809 struct text_pos start_pos
= *position
;
4812 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4813 If the result is non-nil, use VALUE instead of SPEC. */
4815 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
4824 if (!NILP (form
) && !EQ (form
, Qt
))
4826 ptrdiff_t count
= SPECPDL_INDEX ();
4827 struct gcpro gcpro1
;
4829 /* Bind `object' to the object having the `display' property, a
4830 buffer or string. Bind `position' to the position in the
4831 object where the property was found, and `buffer-position'
4832 to the current position in the buffer. */
4835 XSETBUFFER (object
, current_buffer
);
4836 specbind (Qobject
, object
);
4837 specbind (Qposition
, make_number (CHARPOS (*position
)));
4838 specbind (Qbuffer_position
, make_number (bufpos
));
4840 form
= safe_eval (form
);
4842 unbind_to (count
, Qnil
);
4848 /* Handle `(height HEIGHT)' specifications. */
4850 && EQ (XCAR (spec
), Qheight
)
4851 && CONSP (XCDR (spec
)))
4855 if (!FRAME_WINDOW_P (it
->f
))
4858 it
->font_height
= XCAR (XCDR (spec
));
4859 if (!NILP (it
->font_height
))
4861 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4862 int new_height
= -1;
4864 if (CONSP (it
->font_height
)
4865 && (EQ (XCAR (it
->font_height
), Qplus
)
4866 || EQ (XCAR (it
->font_height
), Qminus
))
4867 && CONSP (XCDR (it
->font_height
))
4868 && RANGED_INTEGERP (0, XCAR (XCDR (it
->font_height
)), INT_MAX
))
4870 /* `(+ N)' or `(- N)' where N is an integer. */
4871 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4872 if (EQ (XCAR (it
->font_height
), Qplus
))
4874 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4876 else if (FUNCTIONP (it
->font_height
))
4878 /* Call function with current height as argument.
4879 Value is the new height. */
4881 height
= safe_call1 (it
->font_height
,
4882 face
->lface
[LFACE_HEIGHT_INDEX
]);
4883 if (NUMBERP (height
))
4884 new_height
= XFLOATINT (height
);
4886 else if (NUMBERP (it
->font_height
))
4888 /* Value is a multiple of the canonical char height. */
4891 f
= FACE_FROM_ID (it
->f
,
4892 lookup_basic_face (it
->f
, DEFAULT_FACE_ID
));
4893 new_height
= (XFLOATINT (it
->font_height
)
4894 * XINT (f
->lface
[LFACE_HEIGHT_INDEX
]));
4898 /* Evaluate IT->font_height with `height' bound to the
4899 current specified height to get the new height. */
4900 ptrdiff_t count
= SPECPDL_INDEX ();
4902 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4903 value
= safe_eval (it
->font_height
);
4904 unbind_to (count
, Qnil
);
4906 if (NUMBERP (value
))
4907 new_height
= XFLOATINT (value
);
4911 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4918 /* Handle `(space-width WIDTH)'. */
4920 && EQ (XCAR (spec
), Qspace_width
)
4921 && CONSP (XCDR (spec
)))
4925 if (!FRAME_WINDOW_P (it
->f
))
4928 value
= XCAR (XCDR (spec
));
4929 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4930 it
->space_width
= value
;
4936 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4938 && EQ (XCAR (spec
), Qslice
))
4944 if (!FRAME_WINDOW_P (it
->f
))
4947 if (tem
= XCDR (spec
), CONSP (tem
))
4949 it
->slice
.x
= XCAR (tem
);
4950 if (tem
= XCDR (tem
), CONSP (tem
))
4952 it
->slice
.y
= XCAR (tem
);
4953 if (tem
= XCDR (tem
), CONSP (tem
))
4955 it
->slice
.width
= XCAR (tem
);
4956 if (tem
= XCDR (tem
), CONSP (tem
))
4957 it
->slice
.height
= XCAR (tem
);
4966 /* Handle `(raise FACTOR)'. */
4968 && EQ (XCAR (spec
), Qraise
)
4969 && CONSP (XCDR (spec
)))
4973 if (!FRAME_WINDOW_P (it
->f
))
4976 #ifdef HAVE_WINDOW_SYSTEM
4977 value
= XCAR (XCDR (spec
));
4978 if (NUMBERP (value
))
4980 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4981 it
->voffset
= - (XFLOATINT (value
)
4982 * (FONT_HEIGHT (face
->font
)));
4984 #endif /* HAVE_WINDOW_SYSTEM */
4990 /* Don't handle the other kinds of display specifications
4991 inside a string that we got from a `display' property. */
4992 if (it
&& it
->string_from_display_prop_p
)
4995 /* Characters having this form of property are not displayed, so
4996 we have to find the end of the property. */
4999 start_pos
= *position
;
5000 *position
= display_prop_end (it
, object
, start_pos
);
5004 /* Stop the scan at that end position--we assume that all
5005 text properties change there. */
5007 it
->stop_charpos
= position
->charpos
;
5009 /* Handle `(left-fringe BITMAP [FACE])'
5010 and `(right-fringe BITMAP [FACE])'. */
5012 && (EQ (XCAR (spec
), Qleft_fringe
)
5013 || EQ (XCAR (spec
), Qright_fringe
))
5014 && CONSP (XCDR (spec
)))
5020 if (!FRAME_WINDOW_P (it
->f
))
5021 /* If we return here, POSITION has been advanced
5022 across the text with this property. */
5024 /* Synchronize the bidi iterator with POSITION. This is
5025 needed because we are not going to push the iterator
5026 on behalf of this display property, so there will be
5027 no pop_it call to do this synchronization for us. */
5030 it
->position
= *position
;
5031 iterate_out_of_display_property (it
);
5032 *position
= it
->position
;
5037 else if (!frame_window_p
)
5040 #ifdef HAVE_WINDOW_SYSTEM
5041 value
= XCAR (XCDR (spec
));
5042 if (!SYMBOLP (value
)
5043 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
5044 /* If we return here, POSITION has been advanced
5045 across the text with this property. */
5047 if (it
&& it
->bidi_p
)
5049 it
->position
= *position
;
5050 iterate_out_of_display_property (it
);
5051 *position
= it
->position
;
5058 int face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);;
5060 if (CONSP (XCDR (XCDR (spec
))))
5062 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
5063 int face_id2
= lookup_derived_face (it
->f
, face_name
,
5069 /* Save current settings of IT so that we can restore them
5070 when we are finished with the glyph property value. */
5071 push_it (it
, position
);
5073 it
->area
= TEXT_AREA
;
5074 it
->what
= IT_IMAGE
;
5075 it
->image_id
= -1; /* no image */
5076 it
->position
= start_pos
;
5077 it
->object
= NILP (object
) ? it
->w
->contents
: object
;
5078 it
->method
= GET_FROM_IMAGE
;
5079 it
->from_overlay
= Qnil
;
5080 it
->face_id
= face_id
;
5081 it
->from_disp_prop_p
= true;
5083 /* Say that we haven't consumed the characters with
5084 `display' property yet. The call to pop_it in
5085 set_iterator_to_next will clean this up. */
5086 *position
= start_pos
;
5088 if (EQ (XCAR (spec
), Qleft_fringe
))
5090 it
->left_user_fringe_bitmap
= fringe_bitmap
;
5091 it
->left_user_fringe_face_id
= face_id
;
5095 it
->right_user_fringe_bitmap
= fringe_bitmap
;
5096 it
->right_user_fringe_face_id
= face_id
;
5099 #endif /* HAVE_WINDOW_SYSTEM */
5103 /* Prepare to handle `((margin left-margin) ...)',
5104 `((margin right-margin) ...)' and `((margin nil) ...)'
5105 prefixes for display specifications. */
5106 location
= Qunbound
;
5107 if (CONSP (spec
) && CONSP (XCAR (spec
)))
5111 value
= XCDR (spec
);
5113 value
= XCAR (value
);
5116 if (EQ (XCAR (tem
), Qmargin
)
5117 && (tem
= XCDR (tem
),
5118 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
5120 || EQ (tem
, Qleft_margin
)
5121 || EQ (tem
, Qright_margin
))))
5125 if (EQ (location
, Qunbound
))
5131 /* After this point, VALUE is the property after any
5132 margin prefix has been stripped. It must be a string,
5133 an image specification, or `(space ...)'.
5135 LOCATION specifies where to display: `left-margin',
5136 `right-margin' or nil. */
5138 valid_p
= (STRINGP (value
)
5139 #ifdef HAVE_WINDOW_SYSTEM
5140 || ((it
? FRAME_WINDOW_P (it
->f
) : frame_window_p
)
5141 && valid_image_p (value
))
5142 #endif /* not HAVE_WINDOW_SYSTEM */
5143 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
5145 if (valid_p
&& !display_replaced_p
)
5151 /* Callers need to know whether the display spec is any kind
5152 of `(space ...)' spec that is about to affect text-area
5154 if (CONSP (value
) && EQ (XCAR (value
), Qspace
) && NILP (location
))
5159 /* Save current settings of IT so that we can restore them
5160 when we are finished with the glyph property value. */
5161 push_it (it
, position
);
5162 it
->from_overlay
= overlay
;
5163 it
->from_disp_prop_p
= true;
5165 if (NILP (location
))
5166 it
->area
= TEXT_AREA
;
5167 else if (EQ (location
, Qleft_margin
))
5168 it
->area
= LEFT_MARGIN_AREA
;
5170 it
->area
= RIGHT_MARGIN_AREA
;
5172 if (STRINGP (value
))
5175 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5176 it
->current
.overlay_string_index
= -1;
5177 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5178 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
5179 it
->method
= GET_FROM_STRING
;
5180 it
->stop_charpos
= 0;
5182 it
->base_level_stop
= 0;
5183 it
->string_from_display_prop_p
= true;
5184 /* Say that we haven't consumed the characters with
5185 `display' property yet. The call to pop_it in
5186 set_iterator_to_next will clean this up. */
5187 if (BUFFERP (object
))
5188 *position
= start_pos
;
5190 /* Force paragraph direction to be that of the parent
5191 object. If the parent object's paragraph direction is
5192 not yet determined, default to L2R. */
5193 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5194 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5196 it
->paragraph_embedding
= L2R
;
5198 /* Set up the bidi iterator for this display string. */
5201 it
->bidi_it
.string
.lstring
= it
->string
;
5202 it
->bidi_it
.string
.s
= NULL
;
5203 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5204 it
->bidi_it
.string
.bufpos
= bufpos
;
5205 it
->bidi_it
.string
.from_disp_str
= 1;
5206 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5207 it
->bidi_it
.w
= it
->w
;
5208 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5211 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
5213 it
->method
= GET_FROM_STRETCH
;
5215 *position
= it
->position
= start_pos
;
5216 retval
= 1 + (it
->area
== TEXT_AREA
);
5218 #ifdef HAVE_WINDOW_SYSTEM
5221 it
->what
= IT_IMAGE
;
5222 it
->image_id
= lookup_image (it
->f
, value
);
5223 it
->position
= start_pos
;
5224 it
->object
= NILP (object
) ? it
->w
->contents
: object
;
5225 it
->method
= GET_FROM_IMAGE
;
5227 /* Say that we haven't consumed the characters with
5228 `display' property yet. The call to pop_it in
5229 set_iterator_to_next will clean this up. */
5230 *position
= start_pos
;
5232 #endif /* HAVE_WINDOW_SYSTEM */
5237 /* Invalid property or property not supported. Restore
5238 POSITION to what it was before. */
5239 *position
= start_pos
;
5243 /* Check if PROP is a display property value whose text should be
5244 treated as intangible. OVERLAY is the overlay from which PROP
5245 came, or nil if it came from a text property. CHARPOS and BYTEPOS
5246 specify the buffer position covered by PROP. */
5249 display_prop_intangible_p (Lisp_Object prop
, Lisp_Object overlay
,
5250 ptrdiff_t charpos
, ptrdiff_t bytepos
)
5252 int frame_window_p
= FRAME_WINDOW_P (XFRAME (selected_frame
));
5253 struct text_pos position
;
5255 SET_TEXT_POS (position
, charpos
, bytepos
);
5256 return handle_display_spec (NULL
, prop
, Qnil
, overlay
,
5257 &position
, charpos
, frame_window_p
);
5261 /* Return 1 if PROP is a display sub-property value containing STRING.
5263 Implementation note: this and the following function are really
5264 special cases of handle_display_spec and
5265 handle_single_display_spec, and should ideally use the same code.
5266 Until they do, these two pairs must be consistent and must be
5267 modified in sync. */
5270 single_display_spec_string_p (Lisp_Object prop
, Lisp_Object string
)
5272 if (EQ (string
, prop
))
5275 /* Skip over `when FORM'. */
5276 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
5281 /* Actually, the condition following `when' should be eval'ed,
5282 like handle_single_display_spec does, and we should return
5283 zero if it evaluates to nil. However, this function is
5284 called only when the buffer was already displayed and some
5285 glyph in the glyph matrix was found to come from a display
5286 string. Therefore, the condition was already evaluated, and
5287 the result was non-nil, otherwise the display string wouldn't
5288 have been displayed and we would have never been called for
5289 this property. Thus, we can skip the evaluation and assume
5290 its result is non-nil. */
5295 /* Skip over `margin LOCATION'. */
5296 if (EQ (XCAR (prop
), Qmargin
))
5307 return EQ (prop
, string
) || (CONSP (prop
) && EQ (XCAR (prop
), string
));
5311 /* Return 1 if STRING appears in the `display' property PROP. */
5314 display_prop_string_p (Lisp_Object prop
, Lisp_Object string
)
5317 && !EQ (XCAR (prop
), Qwhen
)
5318 && !(CONSP (XCAR (prop
)) && EQ (Qmargin
, XCAR (XCAR (prop
)))))
5320 /* A list of sub-properties. */
5321 while (CONSP (prop
))
5323 if (single_display_spec_string_p (XCAR (prop
), string
))
5328 else if (VECTORP (prop
))
5330 /* A vector of sub-properties. */
5332 for (i
= 0; i
< ASIZE (prop
); ++i
)
5333 if (single_display_spec_string_p (AREF (prop
, i
), string
))
5337 return single_display_spec_string_p (prop
, string
);
5342 /* Look for STRING in overlays and text properties in the current
5343 buffer, between character positions FROM and TO (excluding TO).
5344 BACK_P non-zero means look back (in this case, TO is supposed to be
5346 Value is the first character position where STRING was found, or
5347 zero if it wasn't found before hitting TO.
5349 This function may only use code that doesn't eval because it is
5350 called asynchronously from note_mouse_highlight. */
5353 string_buffer_position_lim (Lisp_Object string
,
5354 ptrdiff_t from
, ptrdiff_t to
, int back_p
)
5356 Lisp_Object limit
, prop
, pos
;
5359 pos
= make_number (max (from
, BEGV
));
5361 if (!back_p
) /* looking forward */
5363 limit
= make_number (min (to
, ZV
));
5364 while (!found
&& !EQ (pos
, limit
))
5366 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5367 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5370 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
,
5374 else /* looking back */
5376 limit
= make_number (max (to
, BEGV
));
5377 while (!found
&& !EQ (pos
, limit
))
5379 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5380 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5383 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
5388 return found
? XINT (pos
) : 0;
5391 /* Determine which buffer position in current buffer STRING comes from.
5392 AROUND_CHARPOS is an approximate position where it could come from.
5393 Value is the buffer position or 0 if it couldn't be determined.
5395 This function is necessary because we don't record buffer positions
5396 in glyphs generated from strings (to keep struct glyph small).
5397 This function may only use code that doesn't eval because it is
5398 called asynchronously from note_mouse_highlight. */
5401 string_buffer_position (Lisp_Object string
, ptrdiff_t around_charpos
)
5403 const int MAX_DISTANCE
= 1000;
5404 ptrdiff_t found
= string_buffer_position_lim (string
, around_charpos
,
5405 around_charpos
+ MAX_DISTANCE
,
5409 found
= string_buffer_position_lim (string
, around_charpos
,
5410 around_charpos
- MAX_DISTANCE
, 1);
5416 /***********************************************************************
5417 `composition' property
5418 ***********************************************************************/
5420 /* Set up iterator IT from `composition' property at its current
5421 position. Called from handle_stop. */
5423 static enum prop_handled
5424 handle_composition_prop (struct it
*it
)
5426 Lisp_Object prop
, string
;
5427 ptrdiff_t pos
, pos_byte
, start
, end
;
5429 if (STRINGP (it
->string
))
5433 pos
= IT_STRING_CHARPOS (*it
);
5434 pos_byte
= IT_STRING_BYTEPOS (*it
);
5435 string
= it
->string
;
5436 s
= SDATA (string
) + pos_byte
;
5437 it
->c
= STRING_CHAR (s
);
5441 pos
= IT_CHARPOS (*it
);
5442 pos_byte
= IT_BYTEPOS (*it
);
5444 it
->c
= FETCH_CHAR (pos_byte
);
5447 /* If there's a valid composition and point is not inside of the
5448 composition (in the case that the composition is from the current
5449 buffer), draw a glyph composed from the composition components. */
5450 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
5451 && composition_valid_p (start
, end
, prop
)
5452 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
5455 /* As we can't handle this situation (perhaps font-lock added
5456 a new composition), we just return here hoping that next
5457 redisplay will detect this composition much earlier. */
5458 return HANDLED_NORMALLY
;
5461 if (STRINGP (it
->string
))
5462 pos_byte
= string_char_to_byte (it
->string
, start
);
5464 pos_byte
= CHAR_TO_BYTE (start
);
5466 it
->cmp_it
.id
= get_composition_id (start
, pos_byte
, end
- start
,
5469 if (it
->cmp_it
.id
>= 0)
5472 it
->cmp_it
.nchars
= COMPOSITION_LENGTH (prop
);
5473 it
->cmp_it
.nglyphs
= -1;
5477 return HANDLED_NORMALLY
;
5482 /***********************************************************************
5484 ***********************************************************************/
5486 /* The following structure is used to record overlay strings for
5487 later sorting in load_overlay_strings. */
5489 struct overlay_entry
5491 Lisp_Object overlay
;
5498 /* Set up iterator IT from overlay strings at its current position.
5499 Called from handle_stop. */
5501 static enum prop_handled
5502 handle_overlay_change (struct it
*it
)
5504 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
5505 return HANDLED_RECOMPUTE_PROPS
;
5507 return HANDLED_NORMALLY
;
5511 /* Set up the next overlay string for delivery by IT, if there is an
5512 overlay string to deliver. Called by set_iterator_to_next when the
5513 end of the current overlay string is reached. If there are more
5514 overlay strings to display, IT->string and
5515 IT->current.overlay_string_index are set appropriately here.
5516 Otherwise IT->string is set to nil. */
5519 next_overlay_string (struct it
*it
)
5521 ++it
->current
.overlay_string_index
;
5522 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
5524 /* No more overlay strings. Restore IT's settings to what
5525 they were before overlay strings were processed, and
5526 continue to deliver from current_buffer. */
5528 it
->ellipsis_p
= (it
->stack
[it
->sp
- 1].display_ellipsis_p
!= 0);
5531 || (NILP (it
->string
)
5532 && it
->method
== GET_FROM_BUFFER
5533 && it
->stop_charpos
>= BEGV
5534 && it
->stop_charpos
<= it
->end_charpos
));
5535 it
->current
.overlay_string_index
= -1;
5536 it
->n_overlay_strings
= 0;
5537 it
->overlay_strings_charpos
= -1;
5538 /* If there's an empty display string on the stack, pop the
5539 stack, to resync the bidi iterator with IT's position. Such
5540 empty strings are pushed onto the stack in
5541 get_overlay_strings_1. */
5542 if (it
->sp
> 0 && STRINGP (it
->string
) && !SCHARS (it
->string
))
5545 /* If we're at the end of the buffer, record that we have
5546 processed the overlay strings there already, so that
5547 next_element_from_buffer doesn't try it again. */
5548 if (NILP (it
->string
) && IT_CHARPOS (*it
) >= it
->end_charpos
)
5549 it
->overlay_strings_at_end_processed_p
= true;
5553 /* There are more overlay strings to process. If
5554 IT->current.overlay_string_index has advanced to a position
5555 where we must load IT->overlay_strings with more strings, do
5556 it. We must load at the IT->overlay_strings_charpos where
5557 IT->n_overlay_strings was originally computed; when invisible
5558 text is present, this might not be IT_CHARPOS (Bug#7016). */
5559 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
5561 if (it
->current
.overlay_string_index
&& i
== 0)
5562 load_overlay_strings (it
, it
->overlay_strings_charpos
);
5564 /* Initialize IT to deliver display elements from the overlay
5566 it
->string
= it
->overlay_strings
[i
];
5567 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5568 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
5569 it
->method
= GET_FROM_STRING
;
5570 it
->stop_charpos
= 0;
5571 it
->end_charpos
= SCHARS (it
->string
);
5572 if (it
->cmp_it
.stop_pos
>= 0)
5573 it
->cmp_it
.stop_pos
= 0;
5575 it
->base_level_stop
= 0;
5577 /* Set up the bidi iterator for this overlay string. */
5580 it
->bidi_it
.string
.lstring
= it
->string
;
5581 it
->bidi_it
.string
.s
= NULL
;
5582 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5583 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
5584 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5585 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5586 it
->bidi_it
.w
= it
->w
;
5587 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5595 /* Compare two overlay_entry structures E1 and E2. Used as a
5596 comparison function for qsort in load_overlay_strings. Overlay
5597 strings for the same position are sorted so that
5599 1. All after-strings come in front of before-strings, except
5600 when they come from the same overlay.
5602 2. Within after-strings, strings are sorted so that overlay strings
5603 from overlays with higher priorities come first.
5605 2. Within before-strings, strings are sorted so that overlay
5606 strings from overlays with higher priorities come last.
5608 Value is analogous to strcmp. */
5612 compare_overlay_entries (const void *e1
, const void *e2
)
5614 struct overlay_entry
const *entry1
= e1
;
5615 struct overlay_entry
const *entry2
= e2
;
5618 if (entry1
->after_string_p
!= entry2
->after_string_p
)
5620 /* Let after-strings appear in front of before-strings if
5621 they come from different overlays. */
5622 if (EQ (entry1
->overlay
, entry2
->overlay
))
5623 result
= entry1
->after_string_p
? 1 : -1;
5625 result
= entry1
->after_string_p
? -1 : 1;
5627 else if (entry1
->priority
!= entry2
->priority
)
5629 if (entry1
->after_string_p
)
5630 /* After-strings sorted in order of decreasing priority. */
5631 result
= entry2
->priority
< entry1
->priority
? -1 : 1;
5633 /* Before-strings sorted in order of increasing priority. */
5634 result
= entry1
->priority
< entry2
->priority
? -1 : 1;
5643 /* Load the vector IT->overlay_strings with overlay strings from IT's
5644 current buffer position, or from CHARPOS if that is > 0. Set
5645 IT->n_overlays to the total number of overlay strings found.
5647 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
5648 a time. On entry into load_overlay_strings,
5649 IT->current.overlay_string_index gives the number of overlay
5650 strings that have already been loaded by previous calls to this
5653 IT->add_overlay_start contains an additional overlay start
5654 position to consider for taking overlay strings from, if non-zero.
5655 This position comes into play when the overlay has an `invisible'
5656 property, and both before and after-strings. When we've skipped to
5657 the end of the overlay, because of its `invisible' property, we
5658 nevertheless want its before-string to appear.
5659 IT->add_overlay_start will contain the overlay start position
5662 Overlay strings are sorted so that after-string strings come in
5663 front of before-string strings. Within before and after-strings,
5664 strings are sorted by overlay priority. See also function
5665 compare_overlay_entries. */
5668 load_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5670 Lisp_Object overlay
, window
, str
, invisible
;
5671 struct Lisp_Overlay
*ov
;
5672 ptrdiff_t start
, end
;
5673 ptrdiff_t size
= 20;
5674 ptrdiff_t n
= 0, i
, j
;
5676 struct overlay_entry
*entries
= alloca (size
* sizeof *entries
);
5680 charpos
= IT_CHARPOS (*it
);
5682 /* Append the overlay string STRING of overlay OVERLAY to vector
5683 `entries' which has size `size' and currently contains `n'
5684 elements. AFTER_P non-zero means STRING is an after-string of
5686 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5689 Lisp_Object priority; \
5693 struct overlay_entry *old = entries; \
5694 SAFE_NALLOCA (entries, 2, size); \
5695 memcpy (entries, old, size * sizeof *entries); \
5699 entries[n].string = (STRING); \
5700 entries[n].overlay = (OVERLAY); \
5701 priority = Foverlay_get ((OVERLAY), Qpriority); \
5702 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5703 entries[n].after_string_p = (AFTER_P); \
5708 /* Process overlay before the overlay center. */
5709 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
5711 XSETMISC (overlay
, ov
);
5712 eassert (OVERLAYP (overlay
));
5713 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5714 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5719 /* Skip this overlay if it doesn't start or end at IT's current
5721 if (end
!= charpos
&& start
!= charpos
)
5724 /* Skip this overlay if it doesn't apply to IT->w. */
5725 window
= Foverlay_get (overlay
, Qwindow
);
5726 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5729 /* If the text ``under'' the overlay is invisible, both before-
5730 and after-strings from this overlay are visible; start and
5731 end position are indistinguishable. */
5732 invisible
= Foverlay_get (overlay
, Qinvisible
);
5733 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5735 /* If overlay has a non-empty before-string, record it. */
5736 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5737 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5739 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5741 /* If overlay has a non-empty after-string, record it. */
5742 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5743 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5745 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5748 /* Process overlays after the overlay center. */
5749 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
5751 XSETMISC (overlay
, ov
);
5752 eassert (OVERLAYP (overlay
));
5753 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5754 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5756 if (start
> charpos
)
5759 /* Skip this overlay if it doesn't start or end at IT's current
5761 if (end
!= charpos
&& start
!= charpos
)
5764 /* Skip this overlay if it doesn't apply to IT->w. */
5765 window
= Foverlay_get (overlay
, Qwindow
);
5766 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5769 /* If the text ``under'' the overlay is invisible, it has a zero
5770 dimension, and both before- and after-strings apply. */
5771 invisible
= Foverlay_get (overlay
, Qinvisible
);
5772 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5774 /* If overlay has a non-empty before-string, record it. */
5775 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5776 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5778 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5780 /* If overlay has a non-empty after-string, record it. */
5781 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5782 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5784 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5787 #undef RECORD_OVERLAY_STRING
5791 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
5793 /* Record number of overlay strings, and where we computed it. */
5794 it
->n_overlay_strings
= n
;
5795 it
->overlay_strings_charpos
= charpos
;
5797 /* IT->current.overlay_string_index is the number of overlay strings
5798 that have already been consumed by IT. Copy some of the
5799 remaining overlay strings to IT->overlay_strings. */
5801 j
= it
->current
.overlay_string_index
;
5802 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
5804 it
->overlay_strings
[i
] = entries
[j
].string
;
5805 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
5813 /* Get the first chunk of overlay strings at IT's current buffer
5814 position, or at CHARPOS if that is > 0. Value is non-zero if at
5815 least one overlay string was found. */
5818 get_overlay_strings_1 (struct it
*it
, ptrdiff_t charpos
, int compute_stop_p
)
5820 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5821 process. This fills IT->overlay_strings with strings, and sets
5822 IT->n_overlay_strings to the total number of strings to process.
5823 IT->pos.overlay_string_index has to be set temporarily to zero
5824 because load_overlay_strings needs this; it must be set to -1
5825 when no overlay strings are found because a zero value would
5826 indicate a position in the first overlay string. */
5827 it
->current
.overlay_string_index
= 0;
5828 load_overlay_strings (it
, charpos
);
5830 /* If we found overlay strings, set up IT to deliver display
5831 elements from the first one. Otherwise set up IT to deliver
5832 from current_buffer. */
5833 if (it
->n_overlay_strings
)
5835 /* Make sure we know settings in current_buffer, so that we can
5836 restore meaningful values when we're done with the overlay
5839 compute_stop_pos (it
);
5840 eassert (it
->face_id
>= 0);
5842 /* Save IT's settings. They are restored after all overlay
5843 strings have been processed. */
5844 eassert (!compute_stop_p
|| it
->sp
== 0);
5846 /* When called from handle_stop, there might be an empty display
5847 string loaded. In that case, don't bother saving it. But
5848 don't use this optimization with the bidi iterator, since we
5849 need the corresponding pop_it call to resync the bidi
5850 iterator's position with IT's position, after we are done
5851 with the overlay strings. (The corresponding call to pop_it
5852 in case of an empty display string is in
5853 next_overlay_string.) */
5855 && STRINGP (it
->string
) && !SCHARS (it
->string
)))
5858 /* Set up IT to deliver display elements from the first overlay
5860 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5861 it
->string
= it
->overlay_strings
[0];
5862 it
->from_overlay
= Qnil
;
5863 it
->stop_charpos
= 0;
5864 eassert (STRINGP (it
->string
));
5865 it
->end_charpos
= SCHARS (it
->string
);
5867 it
->base_level_stop
= 0;
5868 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5869 it
->method
= GET_FROM_STRING
;
5870 it
->from_disp_prop_p
= 0;
5872 /* Force paragraph direction to be that of the parent
5874 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5875 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5877 it
->paragraph_embedding
= L2R
;
5879 /* Set up the bidi iterator for this overlay string. */
5882 ptrdiff_t pos
= (charpos
> 0 ? charpos
: IT_CHARPOS (*it
));
5884 it
->bidi_it
.string
.lstring
= it
->string
;
5885 it
->bidi_it
.string
.s
= NULL
;
5886 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5887 it
->bidi_it
.string
.bufpos
= pos
;
5888 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5889 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5890 it
->bidi_it
.w
= it
->w
;
5891 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5896 it
->current
.overlay_string_index
= -1;
5901 get_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5904 it
->method
= GET_FROM_BUFFER
;
5906 (void) get_overlay_strings_1 (it
, charpos
, 1);
5910 /* Value is non-zero if we found at least one overlay string. */
5911 return STRINGP (it
->string
);
5916 /***********************************************************************
5917 Saving and restoring state
5918 ***********************************************************************/
5920 /* Save current settings of IT on IT->stack. Called, for example,
5921 before setting up IT for an overlay string, to be able to restore
5922 IT's settings to what they were after the overlay string has been
5923 processed. If POSITION is non-NULL, it is the position to save on
5924 the stack instead of IT->position. */
5927 push_it (struct it
*it
, struct text_pos
*position
)
5929 struct iterator_stack_entry
*p
;
5931 eassert (it
->sp
< IT_STACK_SIZE
);
5932 p
= it
->stack
+ it
->sp
;
5934 p
->stop_charpos
= it
->stop_charpos
;
5935 p
->prev_stop
= it
->prev_stop
;
5936 p
->base_level_stop
= it
->base_level_stop
;
5937 p
->cmp_it
= it
->cmp_it
;
5938 eassert (it
->face_id
>= 0);
5939 p
->face_id
= it
->face_id
;
5940 p
->string
= it
->string
;
5941 p
->method
= it
->method
;
5942 p
->from_overlay
= it
->from_overlay
;
5945 case GET_FROM_IMAGE
:
5946 p
->u
.image
.object
= it
->object
;
5947 p
->u
.image
.image_id
= it
->image_id
;
5948 p
->u
.image
.slice
= it
->slice
;
5950 case GET_FROM_STRETCH
:
5951 p
->u
.stretch
.object
= it
->object
;
5954 p
->position
= position
? *position
: it
->position
;
5955 p
->current
= it
->current
;
5956 p
->end_charpos
= it
->end_charpos
;
5957 p
->string_nchars
= it
->string_nchars
;
5959 p
->multibyte_p
= it
->multibyte_p
;
5960 p
->avoid_cursor_p
= it
->avoid_cursor_p
;
5961 p
->space_width
= it
->space_width
;
5962 p
->font_height
= it
->font_height
;
5963 p
->voffset
= it
->voffset
;
5964 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5965 p
->string_from_prefix_prop_p
= it
->string_from_prefix_prop_p
;
5966 p
->display_ellipsis_p
= 0;
5967 p
->line_wrap
= it
->line_wrap
;
5968 p
->bidi_p
= it
->bidi_p
;
5969 p
->paragraph_embedding
= it
->paragraph_embedding
;
5970 p
->from_disp_prop_p
= it
->from_disp_prop_p
;
5973 /* Save the state of the bidi iterator as well. */
5975 bidi_push_it (&it
->bidi_it
);
5979 iterate_out_of_display_property (struct it
*it
)
5981 int buffer_p
= !STRINGP (it
->string
);
5982 ptrdiff_t eob
= (buffer_p
? ZV
: it
->end_charpos
);
5983 ptrdiff_t bob
= (buffer_p
? BEGV
: 0);
5985 eassert (eob
>= CHARPOS (it
->position
) && CHARPOS (it
->position
) >= bob
);
5987 /* Maybe initialize paragraph direction. If we are at the beginning
5988 of a new paragraph, next_element_from_buffer may not have a
5989 chance to do that. */
5990 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< eob
)
5991 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
5992 /* prev_stop can be zero, so check against BEGV as well. */
5993 while (it
->bidi_it
.charpos
>= bob
5994 && it
->prev_stop
<= it
->bidi_it
.charpos
5995 && it
->bidi_it
.charpos
< CHARPOS (it
->position
)
5996 && it
->bidi_it
.charpos
< eob
)
5997 bidi_move_to_visually_next (&it
->bidi_it
);
5998 /* Record the stop_pos we just crossed, for when we cross it
6000 if (it
->bidi_it
.charpos
> CHARPOS (it
->position
))
6001 it
->prev_stop
= CHARPOS (it
->position
);
6002 /* If we ended up not where pop_it put us, resync IT's
6003 positional members with the bidi iterator. */
6004 if (it
->bidi_it
.charpos
!= CHARPOS (it
->position
))
6005 SET_TEXT_POS (it
->position
, it
->bidi_it
.charpos
, it
->bidi_it
.bytepos
);
6007 it
->current
.pos
= it
->position
;
6009 it
->current
.string_pos
= it
->position
;
6012 /* Restore IT's settings from IT->stack. Called, for example, when no
6013 more overlay strings must be processed, and we return to delivering
6014 display elements from a buffer, or when the end of a string from a
6015 `display' property is reached and we return to delivering display
6016 elements from an overlay string, or from a buffer. */
6019 pop_it (struct it
*it
)
6021 struct iterator_stack_entry
*p
;
6022 int from_display_prop
= it
->from_disp_prop_p
;
6024 eassert (it
->sp
> 0);
6026 p
= it
->stack
+ it
->sp
;
6027 it
->stop_charpos
= p
->stop_charpos
;
6028 it
->prev_stop
= p
->prev_stop
;
6029 it
->base_level_stop
= p
->base_level_stop
;
6030 it
->cmp_it
= p
->cmp_it
;
6031 it
->face_id
= p
->face_id
;
6032 it
->current
= p
->current
;
6033 it
->position
= p
->position
;
6034 it
->string
= p
->string
;
6035 it
->from_overlay
= p
->from_overlay
;
6036 if (NILP (it
->string
))
6037 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
6038 it
->method
= p
->method
;
6041 case GET_FROM_IMAGE
:
6042 it
->image_id
= p
->u
.image
.image_id
;
6043 it
->object
= p
->u
.image
.object
;
6044 it
->slice
= p
->u
.image
.slice
;
6046 case GET_FROM_STRETCH
:
6047 it
->object
= p
->u
.stretch
.object
;
6049 case GET_FROM_BUFFER
:
6050 it
->object
= it
->w
->contents
;
6052 case GET_FROM_STRING
:
6054 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
6056 /* Restore the face_box_p flag, since it could have been
6057 overwritten by the face of the object that we just finished
6060 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
6061 it
->object
= it
->string
;
6064 case GET_FROM_DISPLAY_VECTOR
:
6066 it
->method
= GET_FROM_C_STRING
;
6067 else if (STRINGP (it
->string
))
6068 it
->method
= GET_FROM_STRING
;
6071 it
->method
= GET_FROM_BUFFER
;
6072 it
->object
= it
->w
->contents
;
6075 it
->end_charpos
= p
->end_charpos
;
6076 it
->string_nchars
= p
->string_nchars
;
6078 it
->multibyte_p
= p
->multibyte_p
;
6079 it
->avoid_cursor_p
= p
->avoid_cursor_p
;
6080 it
->space_width
= p
->space_width
;
6081 it
->font_height
= p
->font_height
;
6082 it
->voffset
= p
->voffset
;
6083 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
6084 it
->string_from_prefix_prop_p
= p
->string_from_prefix_prop_p
;
6085 it
->line_wrap
= p
->line_wrap
;
6086 it
->bidi_p
= p
->bidi_p
;
6087 it
->paragraph_embedding
= p
->paragraph_embedding
;
6088 it
->from_disp_prop_p
= p
->from_disp_prop_p
;
6091 bidi_pop_it (&it
->bidi_it
);
6092 /* Bidi-iterate until we get out of the portion of text, if any,
6093 covered by a `display' text property or by an overlay with
6094 `display' property. (We cannot just jump there, because the
6095 internal coherency of the bidi iterator state can not be
6096 preserved across such jumps.) We also must determine the
6097 paragraph base direction if the overlay we just processed is
6098 at the beginning of a new paragraph. */
6099 if (from_display_prop
6100 && (it
->method
== GET_FROM_BUFFER
|| it
->method
== GET_FROM_STRING
))
6101 iterate_out_of_display_property (it
);
6103 eassert ((BUFFERP (it
->object
)
6104 && IT_CHARPOS (*it
) == it
->bidi_it
.charpos
6105 && IT_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
6106 || (STRINGP (it
->object
)
6107 && IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
6108 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
6109 || (CONSP (it
->object
) && it
->method
== GET_FROM_STRETCH
));
6115 /***********************************************************************
6117 ***********************************************************************/
6119 /* Set IT's current position to the previous line start. */
6122 back_to_previous_line_start (struct it
*it
)
6124 ptrdiff_t cp
= IT_CHARPOS (*it
), bp
= IT_BYTEPOS (*it
);
6127 IT_CHARPOS (*it
) = find_newline_no_quit (cp
, bp
, -1, &IT_BYTEPOS (*it
));
6131 /* Move IT to the next line start.
6133 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
6134 we skipped over part of the text (as opposed to moving the iterator
6135 continuously over the text). Otherwise, don't change the value
6138 If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
6139 iterator on the newline, if it was found.
6141 Newlines may come from buffer text, overlay strings, or strings
6142 displayed via the `display' property. That's the reason we can't
6143 simply use find_newline_no_quit.
6145 Note that this function may not skip over invisible text that is so
6146 because of text properties and immediately follows a newline. If
6147 it would, function reseat_at_next_visible_line_start, when called
6148 from set_iterator_to_next, would effectively make invisible
6149 characters following a newline part of the wrong glyph row, which
6150 leads to wrong cursor motion. */
6153 forward_to_next_line_start (struct it
*it
, int *skipped_p
,
6154 struct bidi_it
*bidi_it_prev
)
6156 ptrdiff_t old_selective
;
6157 int newline_found_p
, n
;
6158 const int MAX_NEWLINE_DISTANCE
= 500;
6160 /* If already on a newline, just consume it to avoid unintended
6161 skipping over invisible text below. */
6162 if (it
->what
== IT_CHARACTER
6164 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
6166 if (it
->bidi_p
&& bidi_it_prev
)
6167 *bidi_it_prev
= it
->bidi_it
;
6168 set_iterator_to_next (it
, 0);
6173 /* Don't handle selective display in the following. It's (a)
6174 unnecessary because it's done by the caller, and (b) leads to an
6175 infinite recursion because next_element_from_ellipsis indirectly
6176 calls this function. */
6177 old_selective
= it
->selective
;
6180 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
6181 from buffer text. */
6182 for (n
= newline_found_p
= 0;
6183 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
6184 n
+= STRINGP (it
->string
) ? 0 : 1)
6186 if (!get_next_display_element (it
))
6188 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
6189 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
6190 *bidi_it_prev
= it
->bidi_it
;
6191 set_iterator_to_next (it
, 0);
6194 /* If we didn't find a newline near enough, see if we can use a
6196 if (!newline_found_p
)
6198 ptrdiff_t bytepos
, start
= IT_CHARPOS (*it
);
6199 ptrdiff_t limit
= find_newline_no_quit (start
, IT_BYTEPOS (*it
),
6203 eassert (!STRINGP (it
->string
));
6205 /* If there isn't any `display' property in sight, and no
6206 overlays, we can just use the position of the newline in
6208 if (it
->stop_charpos
>= limit
6209 || ((pos
= Fnext_single_property_change (make_number (start
),
6211 make_number (limit
)),
6213 && next_overlay_change (start
) == ZV
))
6217 IT_CHARPOS (*it
) = limit
;
6218 IT_BYTEPOS (*it
) = bytepos
;
6222 struct bidi_it bprev
;
6224 /* Help bidi.c avoid expensive searches for display
6225 properties and overlays, by telling it that there are
6226 none up to `limit'. */
6227 if (it
->bidi_it
.disp_pos
< limit
)
6229 it
->bidi_it
.disp_pos
= limit
;
6230 it
->bidi_it
.disp_prop
= 0;
6233 bprev
= it
->bidi_it
;
6234 bidi_move_to_visually_next (&it
->bidi_it
);
6235 } while (it
->bidi_it
.charpos
!= limit
);
6236 IT_CHARPOS (*it
) = limit
;
6237 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6239 *bidi_it_prev
= bprev
;
6241 *skipped_p
= newline_found_p
= true;
6245 while (get_next_display_element (it
)
6246 && !newline_found_p
)
6248 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
6249 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
6250 *bidi_it_prev
= it
->bidi_it
;
6251 set_iterator_to_next (it
, 0);
6256 it
->selective
= old_selective
;
6257 return newline_found_p
;
6261 /* Set IT's current position to the previous visible line start. Skip
6262 invisible text that is so either due to text properties or due to
6263 selective display. Caution: this does not change IT->current_x and
6267 back_to_previous_visible_line_start (struct it
*it
)
6269 while (IT_CHARPOS (*it
) > BEGV
)
6271 back_to_previous_line_start (it
);
6273 if (IT_CHARPOS (*it
) <= BEGV
)
6276 /* If selective > 0, then lines indented more than its value are
6278 if (it
->selective
> 0
6279 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6283 /* Check the newline before point for invisibility. */
6286 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
6287 Qinvisible
, it
->window
);
6288 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
6292 if (IT_CHARPOS (*it
) <= BEGV
)
6297 void *it2data
= NULL
;
6300 Lisp_Object val
, overlay
;
6302 SAVE_IT (it2
, *it
, it2data
);
6304 /* If newline is part of a composition, continue from start of composition */
6305 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
6306 && beg
< IT_CHARPOS (*it
))
6309 /* If newline is replaced by a display property, find start of overlay
6310 or interval and continue search from that point. */
6311 pos
= --IT_CHARPOS (it2
);
6314 bidi_unshelve_cache (NULL
, 0);
6315 it2
.string_from_display_prop_p
= 0;
6316 it2
.from_disp_prop_p
= 0;
6317 if (handle_display_prop (&it2
) == HANDLED_RETURN
6318 && !NILP (val
= get_char_property_and_overlay
6319 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
6320 && (OVERLAYP (overlay
)
6321 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
6322 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
6324 RESTORE_IT (it
, it
, it2data
);
6328 /* Newline is not replaced by anything -- so we are done. */
6329 RESTORE_IT (it
, it
, it2data
);
6335 IT_CHARPOS (*it
) = beg
;
6336 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
6340 it
->continuation_lines_width
= 0;
6342 eassert (IT_CHARPOS (*it
) >= BEGV
);
6343 eassert (IT_CHARPOS (*it
) == BEGV
6344 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6349 /* Reseat iterator IT at the previous visible line start. Skip
6350 invisible text that is so either due to text properties or due to
6351 selective display. At the end, update IT's overlay information,
6352 face information etc. */
6355 reseat_at_previous_visible_line_start (struct it
*it
)
6357 back_to_previous_visible_line_start (it
);
6358 reseat (it
, it
->current
.pos
, 1);
6363 /* Reseat iterator IT on the next visible line start in the current
6364 buffer. ON_NEWLINE_P non-zero means position IT on the newline
6365 preceding the line start. Skip over invisible text that is so
6366 because of selective display. Compute faces, overlays etc at the
6367 new position. Note that this function does not skip over text that
6368 is invisible because of text properties. */
6371 reseat_at_next_visible_line_start (struct it
*it
, int on_newline_p
)
6373 int newline_found_p
, skipped_p
= 0;
6374 struct bidi_it bidi_it_prev
;
6376 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6378 /* Skip over lines that are invisible because they are indented
6379 more than the value of IT->selective. */
6380 if (it
->selective
> 0)
6381 while (IT_CHARPOS (*it
) < ZV
6382 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6385 eassert (IT_BYTEPOS (*it
) == BEGV
6386 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6388 forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6391 /* Position on the newline if that's what's requested. */
6392 if (on_newline_p
&& newline_found_p
)
6394 if (STRINGP (it
->string
))
6396 if (IT_STRING_CHARPOS (*it
) > 0)
6400 --IT_STRING_CHARPOS (*it
);
6401 --IT_STRING_BYTEPOS (*it
);
6405 /* We need to restore the bidi iterator to the state
6406 it had on the newline, and resync the IT's
6407 position with that. */
6408 it
->bidi_it
= bidi_it_prev
;
6409 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6410 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6414 else if (IT_CHARPOS (*it
) > BEGV
)
6423 /* We need to restore the bidi iterator to the state it
6424 had on the newline and resync IT with that. */
6425 it
->bidi_it
= bidi_it_prev
;
6426 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6427 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6429 reseat (it
, it
->current
.pos
, 0);
6433 reseat (it
, it
->current
.pos
, 0);
6440 /***********************************************************************
6441 Changing an iterator's position
6442 ***********************************************************************/
6444 /* Change IT's current position to POS in current_buffer. If FORCE_P
6445 is non-zero, always check for text properties at the new position.
6446 Otherwise, text properties are only looked up if POS >=
6447 IT->check_charpos of a property. */
6450 reseat (struct it
*it
, struct text_pos pos
, int force_p
)
6452 ptrdiff_t original_pos
= IT_CHARPOS (*it
);
6454 reseat_1 (it
, pos
, 0);
6456 /* Determine where to check text properties. Avoid doing it
6457 where possible because text property lookup is very expensive. */
6459 || CHARPOS (pos
) > it
->stop_charpos
6460 || CHARPOS (pos
) < original_pos
)
6464 /* For bidi iteration, we need to prime prev_stop and
6465 base_level_stop with our best estimations. */
6466 /* Implementation note: Of course, POS is not necessarily a
6467 stop position, so assigning prev_pos to it is a lie; we
6468 should have called compute_stop_backwards. However, if
6469 the current buffer does not include any R2L characters,
6470 that call would be a waste of cycles, because the
6471 iterator will never move back, and thus never cross this
6472 "fake" stop position. So we delay that backward search
6473 until the time we really need it, in next_element_from_buffer. */
6474 if (CHARPOS (pos
) != it
->prev_stop
)
6475 it
->prev_stop
= CHARPOS (pos
);
6476 if (CHARPOS (pos
) < it
->base_level_stop
)
6477 it
->base_level_stop
= 0; /* meaning it's unknown */
6483 it
->prev_stop
= it
->base_level_stop
= 0;
6492 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
6493 IT->stop_pos to POS, also. */
6496 reseat_1 (struct it
*it
, struct text_pos pos
, int set_stop_p
)
6498 /* Don't call this function when scanning a C string. */
6499 eassert (it
->s
== NULL
);
6501 /* POS must be a reasonable value. */
6502 eassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
6504 it
->current
.pos
= it
->position
= pos
;
6505 it
->end_charpos
= ZV
;
6507 it
->current
.dpvec_index
= -1;
6508 it
->current
.overlay_string_index
= -1;
6509 IT_STRING_CHARPOS (*it
) = -1;
6510 IT_STRING_BYTEPOS (*it
) = -1;
6512 it
->method
= GET_FROM_BUFFER
;
6513 it
->object
= it
->w
->contents
;
6514 it
->area
= TEXT_AREA
;
6515 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
6517 it
->string_from_display_prop_p
= 0;
6518 it
->string_from_prefix_prop_p
= 0;
6520 it
->from_disp_prop_p
= 0;
6521 it
->face_before_selective_p
= 0;
6524 bidi_init_it (IT_CHARPOS (*it
), IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6526 bidi_unshelve_cache (NULL
, 0);
6527 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6528 it
->bidi_it
.string
.s
= NULL
;
6529 it
->bidi_it
.string
.lstring
= Qnil
;
6530 it
->bidi_it
.string
.bufpos
= 0;
6531 it
->bidi_it
.string
.from_disp_str
= 0;
6532 it
->bidi_it
.string
.unibyte
= 0;
6533 it
->bidi_it
.w
= it
->w
;
6538 it
->stop_charpos
= CHARPOS (pos
);
6539 it
->base_level_stop
= CHARPOS (pos
);
6541 /* This make the information stored in it->cmp_it invalidate. */
6546 /* Set up IT for displaying a string, starting at CHARPOS in window W.
6547 If S is non-null, it is a C string to iterate over. Otherwise,
6548 STRING gives a Lisp string to iterate over.
6550 If PRECISION > 0, don't return more then PRECISION number of
6551 characters from the string.
6553 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
6554 characters have been returned. FIELD_WIDTH < 0 means an infinite
6557 MULTIBYTE = 0 means disable processing of multibyte characters,
6558 MULTIBYTE > 0 means enable it,
6559 MULTIBYTE < 0 means use IT->multibyte_p.
6561 IT must be initialized via a prior call to init_iterator before
6562 calling this function. */
6565 reseat_to_string (struct it
*it
, const char *s
, Lisp_Object string
,
6566 ptrdiff_t charpos
, ptrdiff_t precision
, int field_width
,
6569 /* No text property checks performed by default, but see below. */
6570 it
->stop_charpos
= -1;
6572 /* Set iterator position and end position. */
6573 memset (&it
->current
, 0, sizeof it
->current
);
6574 it
->current
.overlay_string_index
= -1;
6575 it
->current
.dpvec_index
= -1;
6576 eassert (charpos
>= 0);
6578 /* If STRING is specified, use its multibyteness, otherwise use the
6579 setting of MULTIBYTE, if specified. */
6581 it
->multibyte_p
= multibyte
> 0;
6583 /* Bidirectional reordering of strings is controlled by the default
6584 value of bidi-display-reordering. Don't try to reorder while
6585 loading loadup.el, as the necessary character property tables are
6586 not yet available. */
6589 && !NILP (BVAR (&buffer_defaults
, bidi_display_reordering
));
6593 eassert (STRINGP (string
));
6594 it
->string
= string
;
6596 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
6597 it
->method
= GET_FROM_STRING
;
6598 it
->current
.string_pos
= string_pos (charpos
, string
);
6602 it
->bidi_it
.string
.lstring
= string
;
6603 it
->bidi_it
.string
.s
= NULL
;
6604 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6605 it
->bidi_it
.string
.bufpos
= 0;
6606 it
->bidi_it
.string
.from_disp_str
= 0;
6607 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6608 it
->bidi_it
.w
= it
->w
;
6609 bidi_init_it (charpos
, IT_STRING_BYTEPOS (*it
),
6610 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
6615 it
->s
= (const unsigned char *) s
;
6618 /* Note that we use IT->current.pos, not it->current.string_pos,
6619 for displaying C strings. */
6620 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
6621 if (it
->multibyte_p
)
6623 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
6624 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
6628 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
6629 it
->end_charpos
= it
->string_nchars
= strlen (s
);
6634 it
->bidi_it
.string
.lstring
= Qnil
;
6635 it
->bidi_it
.string
.s
= (const unsigned char *) s
;
6636 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6637 it
->bidi_it
.string
.bufpos
= 0;
6638 it
->bidi_it
.string
.from_disp_str
= 0;
6639 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6640 it
->bidi_it
.w
= it
->w
;
6641 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6644 it
->method
= GET_FROM_C_STRING
;
6647 /* PRECISION > 0 means don't return more than PRECISION characters
6649 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
6651 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
6653 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6656 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
6657 characters have been returned. FIELD_WIDTH == 0 means don't pad,
6658 FIELD_WIDTH < 0 means infinite field width. This is useful for
6659 padding with `-' at the end of a mode line. */
6660 if (field_width
< 0)
6661 field_width
= INFINITY
;
6662 /* Implementation note: We deliberately don't enlarge
6663 it->bidi_it.string.schars here to fit it->end_charpos, because
6664 the bidi iterator cannot produce characters out of thin air. */
6665 if (field_width
> it
->end_charpos
- charpos
)
6666 it
->end_charpos
= charpos
+ field_width
;
6668 /* Use the standard display table for displaying strings. */
6669 if (DISP_TABLE_P (Vstandard_display_table
))
6670 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
6672 it
->stop_charpos
= charpos
;
6673 it
->prev_stop
= charpos
;
6674 it
->base_level_stop
= 0;
6677 it
->bidi_it
.first_elt
= 1;
6678 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6679 it
->bidi_it
.disp_pos
= -1;
6681 if (s
== NULL
&& it
->multibyte_p
)
6683 ptrdiff_t endpos
= SCHARS (it
->string
);
6684 if (endpos
> it
->end_charpos
)
6685 endpos
= it
->end_charpos
;
6686 composition_compute_stop_pos (&it
->cmp_it
, charpos
, -1, endpos
,
6694 /***********************************************************************
6696 ***********************************************************************/
6698 /* Map enum it_method value to corresponding next_element_from_* function. */
6700 static int (* get_next_element
[NUM_IT_METHODS
]) (struct it
*it
) =
6702 next_element_from_buffer
,
6703 next_element_from_display_vector
,
6704 next_element_from_string
,
6705 next_element_from_c_string
,
6706 next_element_from_image
,
6707 next_element_from_stretch
6710 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
6713 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
6714 (possibly with the following characters). */
6716 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
6717 ((IT)->cmp_it.id >= 0 \
6718 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
6719 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
6720 END_CHARPOS, (IT)->w, \
6721 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
6725 /* Lookup the char-table Vglyphless_char_display for character C (-1
6726 if we want information for no-font case), and return the display
6727 method symbol. By side-effect, update it->what and
6728 it->glyphless_method. This function is called from
6729 get_next_display_element for each character element, and from
6730 x_produce_glyphs when no suitable font was found. */
6733 lookup_glyphless_char_display (int c
, struct it
*it
)
6735 Lisp_Object glyphless_method
= Qnil
;
6737 if (CHAR_TABLE_P (Vglyphless_char_display
)
6738 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
)) >= 1)
6742 glyphless_method
= CHAR_TABLE_REF (Vglyphless_char_display
, c
);
6743 if (CONSP (glyphless_method
))
6744 glyphless_method
= FRAME_WINDOW_P (it
->f
)
6745 ? XCAR (glyphless_method
)
6746 : XCDR (glyphless_method
);
6749 glyphless_method
= XCHAR_TABLE (Vglyphless_char_display
)->extras
[0];
6753 if (NILP (glyphless_method
))
6756 /* The default is to display the character by a proper font. */
6758 /* The default for the no-font case is to display an empty box. */
6759 glyphless_method
= Qempty_box
;
6761 if (EQ (glyphless_method
, Qzero_width
))
6764 return glyphless_method
;
6765 /* This method can't be used for the no-font case. */
6766 glyphless_method
= Qempty_box
;
6768 if (EQ (glyphless_method
, Qthin_space
))
6769 it
->glyphless_method
= GLYPHLESS_DISPLAY_THIN_SPACE
;
6770 else if (EQ (glyphless_method
, Qempty_box
))
6771 it
->glyphless_method
= GLYPHLESS_DISPLAY_EMPTY_BOX
;
6772 else if (EQ (glyphless_method
, Qhex_code
))
6773 it
->glyphless_method
= GLYPHLESS_DISPLAY_HEX_CODE
;
6774 else if (STRINGP (glyphless_method
))
6775 it
->glyphless_method
= GLYPHLESS_DISPLAY_ACRONYM
;
6778 /* Invalid value. We use the default method. */
6779 glyphless_method
= Qnil
;
6782 it
->what
= IT_GLYPHLESS
;
6783 return glyphless_method
;
6786 /* Merge escape glyph face and cache the result. */
6788 static struct frame
*last_escape_glyph_frame
= NULL
;
6789 static int last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
6790 static int last_escape_glyph_merged_face_id
= 0;
6793 merge_escape_glyph_face (struct it
*it
)
6797 if (it
->f
== last_escape_glyph_frame
6798 && it
->face_id
== last_escape_glyph_face_id
)
6799 face_id
= last_escape_glyph_merged_face_id
;
6802 /* Merge the `escape-glyph' face into the current face. */
6803 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0, it
->face_id
);
6804 last_escape_glyph_frame
= it
->f
;
6805 last_escape_glyph_face_id
= it
->face_id
;
6806 last_escape_glyph_merged_face_id
= face_id
;
6811 /* Likewise for glyphless glyph face. */
6813 static struct frame
*last_glyphless_glyph_frame
= NULL
;
6814 static int last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
6815 static int last_glyphless_glyph_merged_face_id
= 0;
6818 merge_glyphless_glyph_face (struct it
*it
)
6822 if (it
->f
== last_glyphless_glyph_frame
6823 && it
->face_id
== last_glyphless_glyph_face_id
)
6824 face_id
= last_glyphless_glyph_merged_face_id
;
6827 /* Merge the `glyphless-char' face into the current face. */
6828 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
6829 last_glyphless_glyph_frame
= it
->f
;
6830 last_glyphless_glyph_face_id
= it
->face_id
;
6831 last_glyphless_glyph_merged_face_id
= face_id
;
6836 /* Load IT's display element fields with information about the next
6837 display element from the current position of IT. Value is zero if
6838 end of buffer (or C string) is reached. */
6841 get_next_display_element (struct it
*it
)
6843 /* Non-zero means that we found a display element. Zero means that
6844 we hit the end of what we iterate over. Performance note: the
6845 function pointer `method' used here turns out to be faster than
6846 using a sequence of if-statements. */
6850 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
6852 if (it
->what
== IT_CHARACTER
)
6854 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
6855 and only if (a) the resolved directionality of that character
6857 /* FIXME: Do we need an exception for characters from display
6859 if (it
->bidi_p
&& it
->bidi_it
.type
== STRONG_R
)
6860 it
->c
= bidi_mirror_char (it
->c
);
6861 /* Map via display table or translate control characters.
6862 IT->c, IT->len etc. have been set to the next character by
6863 the function call above. If we have a display table, and it
6864 contains an entry for IT->c, translate it. Don't do this if
6865 IT->c itself comes from a display table, otherwise we could
6866 end up in an infinite recursion. (An alternative could be to
6867 count the recursion depth of this function and signal an
6868 error when a certain maximum depth is reached.) Is it worth
6870 if (success_p
&& it
->dpvec
== NULL
)
6873 struct charset
*unibyte
= CHARSET_FROM_ID (charset_unibyte
);
6874 int nonascii_space_p
= 0;
6875 int nonascii_hyphen_p
= 0;
6876 int c
= it
->c
; /* This is the character to display. */
6878 if (! it
->multibyte_p
&& ! ASCII_CHAR_P (c
))
6880 eassert (SINGLE_BYTE_CHAR_P (c
));
6881 if (unibyte_display_via_language_environment
)
6883 c
= DECODE_CHAR (unibyte
, c
);
6885 c
= BYTE8_TO_CHAR (it
->c
);
6888 c
= BYTE8_TO_CHAR (it
->c
);
6892 && (dv
= DISP_CHAR_VECTOR (it
->dp
, c
),
6895 struct Lisp_Vector
*v
= XVECTOR (dv
);
6897 /* Return the first character from the display table
6898 entry, if not empty. If empty, don't display the
6899 current character. */
6902 it
->dpvec_char_len
= it
->len
;
6903 it
->dpvec
= v
->contents
;
6904 it
->dpend
= v
->contents
+ v
->header
.size
;
6905 it
->current
.dpvec_index
= 0;
6906 it
->dpvec_face_id
= -1;
6907 it
->saved_face_id
= it
->face_id
;
6908 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6913 set_iterator_to_next (it
, 0);
6918 if (! NILP (lookup_glyphless_char_display (c
, it
)))
6920 if (it
->what
== IT_GLYPHLESS
)
6922 /* Don't display this character. */
6923 set_iterator_to_next (it
, 0);
6927 /* If `nobreak-char-display' is non-nil, we display
6928 non-ASCII spaces and hyphens specially. */
6929 if (! ASCII_CHAR_P (c
) && ! NILP (Vnobreak_char_display
))
6932 nonascii_space_p
= true;
6933 else if (c
== 0xAD || c
== 0x2010 || c
== 0x2011)
6934 nonascii_hyphen_p
= true;
6937 /* Translate control characters into `\003' or `^C' form.
6938 Control characters coming from a display table entry are
6939 currently not translated because we use IT->dpvec to hold
6940 the translation. This could easily be changed but I
6941 don't believe that it is worth doing.
6943 The characters handled by `nobreak-char-display' must be
6946 Non-printable characters and raw-byte characters are also
6947 translated to octal form. */
6948 if (((c
< ' ' || c
== 127) /* ASCII control chars. */
6949 ? (it
->area
!= TEXT_AREA
6950 /* In mode line, treat \n, \t like other crl chars. */
6953 && (it
->glyph_row
->mode_line_p
|| it
->avoid_cursor_p
))
6954 || (c
!= '\n' && c
!= '\t'))
6956 || nonascii_hyphen_p
6958 || ! CHAR_PRINTABLE_P (c
))))
6960 /* C is a control character, non-ASCII space/hyphen,
6961 raw-byte, or a non-printable character which must be
6962 displayed either as '\003' or as `^C' where the '\\'
6963 and '^' can be defined in the display table. Fill
6964 IT->ctl_chars with glyphs for what we have to
6965 display. Then, set IT->dpvec to these glyphs. */
6972 /* Handle control characters with ^. */
6974 if (ASCII_CHAR_P (c
) && it
->ctl_arrow_p
)
6978 g
= '^'; /* default glyph for Control */
6979 /* Set IT->ctl_chars[0] to the glyph for `^'. */
6981 && (gc
= DISP_CTRL_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
6983 g
= GLYPH_CODE_CHAR (gc
);
6984 lface_id
= GLYPH_CODE_FACE (gc
);
6988 ? merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
)
6989 : merge_escape_glyph_face (it
));
6991 XSETINT (it
->ctl_chars
[0], g
);
6992 XSETINT (it
->ctl_chars
[1], c
^ 0100);
6994 goto display_control
;
6997 /* Handle non-ascii space in the mode where it only gets
7000 if (nonascii_space_p
&& EQ (Vnobreak_char_display
, Qt
))
7002 /* Merge `nobreak-space' into the current face. */
7003 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
7005 XSETINT (it
->ctl_chars
[0], ' ');
7007 goto display_control
;
7010 /* Handle sequences that start with the "escape glyph". */
7012 /* the default escape glyph is \. */
7013 escape_glyph
= '\\';
7016 && (gc
= DISP_ESCAPE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
7018 escape_glyph
= GLYPH_CODE_CHAR (gc
);
7019 lface_id
= GLYPH_CODE_FACE (gc
);
7023 ? merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
)
7024 : merge_escape_glyph_face (it
));
7026 /* Draw non-ASCII hyphen with just highlighting: */
7028 if (nonascii_hyphen_p
&& EQ (Vnobreak_char_display
, Qt
))
7030 XSETINT (it
->ctl_chars
[0], '-');
7032 goto display_control
;
7035 /* Draw non-ASCII space/hyphen with escape glyph: */
7037 if (nonascii_space_p
|| nonascii_hyphen_p
)
7039 XSETINT (it
->ctl_chars
[0], escape_glyph
);
7040 XSETINT (it
->ctl_chars
[1], nonascii_space_p
? ' ' : '-');
7042 goto display_control
;
7049 if (CHAR_BYTE8_P (c
))
7050 /* Display \200 instead of \17777600. */
7051 c
= CHAR_TO_BYTE8 (c
);
7052 len
= sprintf (str
, "%03o", c
);
7054 XSETINT (it
->ctl_chars
[0], escape_glyph
);
7055 for (i
= 0; i
< len
; i
++)
7056 XSETINT (it
->ctl_chars
[i
+ 1], str
[i
]);
7061 /* Set up IT->dpvec and return first character from it. */
7062 it
->dpvec_char_len
= it
->len
;
7063 it
->dpvec
= it
->ctl_chars
;
7064 it
->dpend
= it
->dpvec
+ ctl_len
;
7065 it
->current
.dpvec_index
= 0;
7066 it
->dpvec_face_id
= face_id
;
7067 it
->saved_face_id
= it
->face_id
;
7068 it
->method
= GET_FROM_DISPLAY_VECTOR
;
7072 it
->char_to_display
= c
;
7076 it
->char_to_display
= it
->c
;
7080 #ifdef HAVE_WINDOW_SYSTEM
7081 /* Adjust face id for a multibyte character. There are no multibyte
7082 character in unibyte text. */
7083 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
7086 && FRAME_WINDOW_P (it
->f
))
7088 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
7090 if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
>= 0)
7092 /* Automatic composition with glyph-string. */
7093 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
7095 it
->face_id
= face_for_font (it
->f
, LGSTRING_FONT (gstring
), face
);
7099 ptrdiff_t pos
= (it
->s
? -1
7100 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
7101 : IT_CHARPOS (*it
));
7104 if (it
->what
== IT_CHARACTER
)
7105 c
= it
->char_to_display
;
7108 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
7112 for (i
= 0; i
< cmp
->glyph_len
; i
++)
7113 /* TAB in a composition means display glyphs with
7114 padding space on the left or right. */
7115 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
7118 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, pos
, it
->string
);
7121 #endif /* HAVE_WINDOW_SYSTEM */
7124 /* Is this character the last one of a run of characters with
7125 box? If yes, set IT->end_of_box_run_p to 1. */
7129 if (it
->method
== GET_FROM_STRING
&& it
->sp
)
7131 int face_id
= underlying_face_id (it
);
7132 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
7136 if (face
->box
== FACE_NO_BOX
)
7138 /* If the box comes from face properties in a
7139 display string, check faces in that string. */
7140 int string_face_id
= face_after_it_pos (it
);
7141 it
->end_of_box_run_p
7142 = (FACE_FROM_ID (it
->f
, string_face_id
)->box
7145 /* Otherwise, the box comes from the underlying face.
7146 If this is the last string character displayed, check
7147 the next buffer location. */
7148 else if ((IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
) - 1)
7149 /* n_overlay_strings is unreliable unless
7150 overlay_string_index is non-negative. */
7151 && ((it
->current
.overlay_string_index
>= 0
7152 && (it
->current
.overlay_string_index
7153 == it
->n_overlay_strings
- 1))
7154 /* A string from display property. */
7155 || it
->from_disp_prop_p
))
7159 struct text_pos pos
= it
->current
.pos
;
7161 /* For a string from a display property, the next
7162 buffer position is stored in the 'position'
7163 member of the iteration stack slot below the
7164 current one, see handle_single_display_spec. By
7165 contrast, it->current.pos was is not yet updated
7166 to point to that buffer position; that will
7167 happen in pop_it, after we finish displaying the
7168 current string. Note that we already checked
7169 above that it->sp is positive, so subtracting one
7171 if (it
->from_disp_prop_p
)
7172 pos
= (it
->stack
+ it
->sp
- 1)->position
;
7174 INC_TEXT_POS (pos
, it
->multibyte_p
);
7176 if (CHARPOS (pos
) >= ZV
)
7177 it
->end_of_box_run_p
= true;
7180 next_face_id
= face_at_buffer_position
7181 (it
->w
, CHARPOS (pos
), &ignore
,
7182 CHARPOS (pos
) + TEXT_PROP_DISTANCE_LIMIT
, 0, -1);
7183 it
->end_of_box_run_p
7184 = (FACE_FROM_ID (it
->f
, next_face_id
)->box
7190 /* next_element_from_display_vector sets this flag according to
7191 faces of the display vector glyphs, see there. */
7192 else if (it
->method
!= GET_FROM_DISPLAY_VECTOR
)
7194 int face_id
= face_after_it_pos (it
);
7195 it
->end_of_box_run_p
7196 = (face_id
!= it
->face_id
7197 && FACE_FROM_ID (it
->f
, face_id
)->box
== FACE_NO_BOX
);
7200 /* If we reached the end of the object we've been iterating (e.g., a
7201 display string or an overlay string), and there's something on
7202 IT->stack, proceed with what's on the stack. It doesn't make
7203 sense to return zero if there's unprocessed stuff on the stack,
7204 because otherwise that stuff will never be displayed. */
7205 if (!success_p
&& it
->sp
> 0)
7207 set_iterator_to_next (it
, 0);
7208 success_p
= get_next_display_element (it
);
7211 /* Value is 0 if end of buffer or string reached. */
7216 /* Move IT to the next display element.
7218 RESEAT_P non-zero means if called on a newline in buffer text,
7219 skip to the next visible line start.
7221 Functions get_next_display_element and set_iterator_to_next are
7222 separate because I find this arrangement easier to handle than a
7223 get_next_display_element function that also increments IT's
7224 position. The way it is we can first look at an iterator's current
7225 display element, decide whether it fits on a line, and if it does,
7226 increment the iterator position. The other way around we probably
7227 would either need a flag indicating whether the iterator has to be
7228 incremented the next time, or we would have to implement a
7229 decrement position function which would not be easy to write. */
7232 set_iterator_to_next (struct it
*it
, int reseat_p
)
7234 /* Reset flags indicating start and end of a sequence of characters
7235 with box. Reset them at the start of this function because
7236 moving the iterator to a new position might set them. */
7237 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
7241 case GET_FROM_BUFFER
:
7242 /* The current display element of IT is a character from
7243 current_buffer. Advance in the buffer, and maybe skip over
7244 invisible lines that are so because of selective display. */
7245 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
7246 reseat_at_next_visible_line_start (it
, 0);
7247 else if (it
->cmp_it
.id
>= 0)
7249 /* We are currently getting glyphs from a composition. */
7254 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7255 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7256 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7258 it
->cmp_it
.from
= it
->cmp_it
.to
;
7263 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7265 it
->end_charpos
, Qnil
);
7268 else if (! it
->cmp_it
.reversed_p
)
7270 /* Composition created while scanning forward. */
7271 /* Update IT's char/byte positions to point to the first
7272 character of the next grapheme cluster, or to the
7273 character visually after the current composition. */
7274 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7275 bidi_move_to_visually_next (&it
->bidi_it
);
7276 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7277 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7279 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7281 /* Proceed to the next grapheme cluster. */
7282 it
->cmp_it
.from
= it
->cmp_it
.to
;
7286 /* No more grapheme clusters in this composition.
7287 Find the next stop position. */
7288 ptrdiff_t stop
= it
->end_charpos
;
7289 if (it
->bidi_it
.scan_dir
< 0)
7290 /* Now we are scanning backward and don't know
7293 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7294 IT_BYTEPOS (*it
), stop
, Qnil
);
7299 /* Composition created while scanning backward. */
7300 /* Update IT's char/byte positions to point to the last
7301 character of the previous grapheme cluster, or the
7302 character visually after the current composition. */
7303 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7304 bidi_move_to_visually_next (&it
->bidi_it
);
7305 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7306 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7307 if (it
->cmp_it
.from
> 0)
7309 /* Proceed to the previous grapheme cluster. */
7310 it
->cmp_it
.to
= it
->cmp_it
.from
;
7314 /* No more grapheme clusters in this composition.
7315 Find the next stop position. */
7316 ptrdiff_t stop
= it
->end_charpos
;
7317 if (it
->bidi_it
.scan_dir
< 0)
7318 /* Now we are scanning backward and don't know
7321 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7322 IT_BYTEPOS (*it
), stop
, Qnil
);
7328 eassert (it
->len
!= 0);
7332 IT_BYTEPOS (*it
) += it
->len
;
7333 IT_CHARPOS (*it
) += 1;
7337 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7338 /* If this is a new paragraph, determine its base
7339 direction (a.k.a. its base embedding level). */
7340 if (it
->bidi_it
.new_paragraph
)
7341 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
7342 bidi_move_to_visually_next (&it
->bidi_it
);
7343 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7344 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7345 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7347 /* As the scan direction was changed, we must
7348 re-compute the stop position for composition. */
7349 ptrdiff_t stop
= it
->end_charpos
;
7350 if (it
->bidi_it
.scan_dir
< 0)
7352 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7353 IT_BYTEPOS (*it
), stop
, Qnil
);
7356 eassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
7360 case GET_FROM_C_STRING
:
7361 /* Current display element of IT is from a C string. */
7363 /* If the string position is beyond string's end, it means
7364 next_element_from_c_string is padding the string with
7365 blanks, in which case we bypass the bidi iterator,
7366 because it cannot deal with such virtual characters. */
7367 || IT_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7369 IT_BYTEPOS (*it
) += it
->len
;
7370 IT_CHARPOS (*it
) += 1;
7374 bidi_move_to_visually_next (&it
->bidi_it
);
7375 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7376 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7380 case GET_FROM_DISPLAY_VECTOR
:
7381 /* Current display element of IT is from a display table entry.
7382 Advance in the display table definition. Reset it to null if
7383 end reached, and continue with characters from buffers/
7385 ++it
->current
.dpvec_index
;
7387 /* Restore face of the iterator to what they were before the
7388 display vector entry (these entries may contain faces). */
7389 it
->face_id
= it
->saved_face_id
;
7391 if (it
->dpvec
+ it
->current
.dpvec_index
>= it
->dpend
)
7393 int recheck_faces
= it
->ellipsis_p
;
7396 it
->method
= GET_FROM_C_STRING
;
7397 else if (STRINGP (it
->string
))
7398 it
->method
= GET_FROM_STRING
;
7401 it
->method
= GET_FROM_BUFFER
;
7402 it
->object
= it
->w
->contents
;
7406 it
->current
.dpvec_index
= -1;
7408 /* Skip over characters which were displayed via IT->dpvec. */
7409 if (it
->dpvec_char_len
< 0)
7410 reseat_at_next_visible_line_start (it
, 1);
7411 else if (it
->dpvec_char_len
> 0)
7413 if (it
->method
== GET_FROM_STRING
7414 && it
->current
.overlay_string_index
>= 0
7415 && it
->n_overlay_strings
> 0)
7416 it
->ignore_overlay_strings_at_pos_p
= true;
7417 it
->len
= it
->dpvec_char_len
;
7418 set_iterator_to_next (it
, reseat_p
);
7421 /* Maybe recheck faces after display vector. */
7423 it
->stop_charpos
= IT_CHARPOS (*it
);
7427 case GET_FROM_STRING
:
7428 /* Current display element is a character from a Lisp string. */
7429 eassert (it
->s
== NULL
&& STRINGP (it
->string
));
7430 /* Don't advance past string end. These conditions are true
7431 when set_iterator_to_next is called at the end of
7432 get_next_display_element, in which case the Lisp string is
7433 already exhausted, and all we want is pop the iterator
7435 if (it
->current
.overlay_string_index
>= 0)
7437 /* This is an overlay string, so there's no padding with
7438 spaces, and the number of characters in the string is
7439 where the string ends. */
7440 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7441 goto consider_string_end
;
7445 /* Not an overlay string. There could be padding, so test
7446 against it->end_charpos. */
7447 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7448 goto consider_string_end
;
7450 if (it
->cmp_it
.id
>= 0)
7456 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7457 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7458 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7459 it
->cmp_it
.from
= it
->cmp_it
.to
;
7463 composition_compute_stop_pos (&it
->cmp_it
,
7464 IT_STRING_CHARPOS (*it
),
7465 IT_STRING_BYTEPOS (*it
),
7466 it
->end_charpos
, it
->string
);
7469 else if (! it
->cmp_it
.reversed_p
)
7471 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7472 bidi_move_to_visually_next (&it
->bidi_it
);
7473 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7474 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7476 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7477 it
->cmp_it
.from
= it
->cmp_it
.to
;
7480 ptrdiff_t stop
= it
->end_charpos
;
7481 if (it
->bidi_it
.scan_dir
< 0)
7483 composition_compute_stop_pos (&it
->cmp_it
,
7484 IT_STRING_CHARPOS (*it
),
7485 IT_STRING_BYTEPOS (*it
), stop
,
7491 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7492 bidi_move_to_visually_next (&it
->bidi_it
);
7493 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7494 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7495 if (it
->cmp_it
.from
> 0)
7496 it
->cmp_it
.to
= it
->cmp_it
.from
;
7499 ptrdiff_t stop
= it
->end_charpos
;
7500 if (it
->bidi_it
.scan_dir
< 0)
7502 composition_compute_stop_pos (&it
->cmp_it
,
7503 IT_STRING_CHARPOS (*it
),
7504 IT_STRING_BYTEPOS (*it
), stop
,
7512 /* If the string position is beyond string's end, it
7513 means next_element_from_string is padding the string
7514 with blanks, in which case we bypass the bidi
7515 iterator, because it cannot deal with such virtual
7517 || IT_STRING_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7519 IT_STRING_BYTEPOS (*it
) += it
->len
;
7520 IT_STRING_CHARPOS (*it
) += 1;
7524 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7526 bidi_move_to_visually_next (&it
->bidi_it
);
7527 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7528 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7529 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7531 ptrdiff_t stop
= it
->end_charpos
;
7533 if (it
->bidi_it
.scan_dir
< 0)
7535 composition_compute_stop_pos (&it
->cmp_it
,
7536 IT_STRING_CHARPOS (*it
),
7537 IT_STRING_BYTEPOS (*it
), stop
,
7543 consider_string_end
:
7545 if (it
->current
.overlay_string_index
>= 0)
7547 /* IT->string is an overlay string. Advance to the
7548 next, if there is one. */
7549 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7552 next_overlay_string (it
);
7554 setup_for_ellipsis (it
, 0);
7559 /* IT->string is not an overlay string. If we reached
7560 its end, and there is something on IT->stack, proceed
7561 with what is on the stack. This can be either another
7562 string, this time an overlay string, or a buffer. */
7563 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
7567 if (it
->method
== GET_FROM_STRING
)
7568 goto consider_string_end
;
7573 case GET_FROM_IMAGE
:
7574 case GET_FROM_STRETCH
:
7575 /* The position etc with which we have to proceed are on
7576 the stack. The position may be at the end of a string,
7577 if the `display' property takes up the whole string. */
7578 eassert (it
->sp
> 0);
7580 if (it
->method
== GET_FROM_STRING
)
7581 goto consider_string_end
;
7585 /* There are no other methods defined, so this should be a bug. */
7589 eassert (it
->method
!= GET_FROM_STRING
7590 || (STRINGP (it
->string
)
7591 && IT_STRING_CHARPOS (*it
) >= 0));
7594 /* Load IT's display element fields with information about the next
7595 display element which comes from a display table entry or from the
7596 result of translating a control character to one of the forms `^C'
7599 IT->dpvec holds the glyphs to return as characters.
7600 IT->saved_face_id holds the face id before the display vector--it
7601 is restored into IT->face_id in set_iterator_to_next. */
7604 next_element_from_display_vector (struct it
*it
)
7607 int prev_face_id
= it
->face_id
;
7611 eassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
7613 it
->face_id
= it
->saved_face_id
;
7615 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
7616 That seemed totally bogus - so I changed it... */
7617 gc
= it
->dpvec
[it
->current
.dpvec_index
];
7619 if (GLYPH_CODE_P (gc
))
7621 struct face
*this_face
, *prev_face
, *next_face
;
7623 it
->c
= GLYPH_CODE_CHAR (gc
);
7624 it
->len
= CHAR_BYTES (it
->c
);
7626 /* The entry may contain a face id to use. Such a face id is
7627 the id of a Lisp face, not a realized face. A face id of
7628 zero means no face is specified. */
7629 if (it
->dpvec_face_id
>= 0)
7630 it
->face_id
= it
->dpvec_face_id
;
7633 int lface_id
= GLYPH_CODE_FACE (gc
);
7635 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
7639 /* Glyphs in the display vector could have the box face, so we
7640 need to set the related flags in the iterator, as
7642 this_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
7643 prev_face
= FACE_FROM_ID (it
->f
, prev_face_id
);
7645 /* Is this character the first character of a box-face run? */
7646 it
->start_of_box_run_p
= (this_face
&& this_face
->box
!= FACE_NO_BOX
7648 || prev_face
->box
== FACE_NO_BOX
));
7650 /* For the last character of the box-face run, we need to look
7651 either at the next glyph from the display vector, or at the
7652 face we saw before the display vector. */
7653 next_face_id
= it
->saved_face_id
;
7654 if (it
->current
.dpvec_index
< it
->dpend
- it
->dpvec
- 1)
7656 if (it
->dpvec_face_id
>= 0)
7657 next_face_id
= it
->dpvec_face_id
;
7661 GLYPH_CODE_FACE (it
->dpvec
[it
->current
.dpvec_index
+ 1]);
7664 next_face_id
= merge_faces (it
->f
, Qt
, lface_id
,
7668 next_face
= FACE_FROM_ID (it
->f
, next_face_id
);
7669 it
->end_of_box_run_p
= (this_face
&& this_face
->box
!= FACE_NO_BOX
7671 || next_face
->box
== FACE_NO_BOX
));
7672 it
->face_box_p
= this_face
&& this_face
->box
!= FACE_NO_BOX
;
7675 /* Display table entry is invalid. Return a space. */
7676 it
->c
= ' ', it
->len
= 1;
7678 /* Don't change position and object of the iterator here. They are
7679 still the values of the character that had this display table
7680 entry or was translated, and that's what we want. */
7681 it
->what
= IT_CHARACTER
;
7685 /* Get the first element of string/buffer in the visual order, after
7686 being reseated to a new position in a string or a buffer. */
7688 get_visually_first_element (struct it
*it
)
7690 int string_p
= STRINGP (it
->string
) || it
->s
;
7691 ptrdiff_t eob
= (string_p
? it
->bidi_it
.string
.schars
: ZV
);
7692 ptrdiff_t bob
= (string_p
? 0 : BEGV
);
7694 if (STRINGP (it
->string
))
7696 it
->bidi_it
.charpos
= IT_STRING_CHARPOS (*it
);
7697 it
->bidi_it
.bytepos
= IT_STRING_BYTEPOS (*it
);
7701 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
7702 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
7705 if (it
->bidi_it
.charpos
== eob
)
7707 /* Nothing to do, but reset the FIRST_ELT flag, like
7708 bidi_paragraph_init does, because we are not going to
7710 it
->bidi_it
.first_elt
= 0;
7712 else if (it
->bidi_it
.charpos
== bob
7714 && (FETCH_CHAR (it
->bidi_it
.bytepos
- 1) == '\n'
7715 || FETCH_CHAR (it
->bidi_it
.bytepos
) == '\n')))
7717 /* If we are at the beginning of a line/string, we can produce
7718 the next element right away. */
7719 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7720 bidi_move_to_visually_next (&it
->bidi_it
);
7724 ptrdiff_t orig_bytepos
= it
->bidi_it
.bytepos
;
7726 /* We need to prime the bidi iterator starting at the line's or
7727 string's beginning, before we will be able to produce the
7730 it
->bidi_it
.charpos
= it
->bidi_it
.bytepos
= 0;
7732 it
->bidi_it
.charpos
= find_newline_no_quit (IT_CHARPOS (*it
),
7733 IT_BYTEPOS (*it
), -1,
7734 &it
->bidi_it
.bytepos
);
7735 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7738 /* Now return to buffer/string position where we were asked
7739 to get the next display element, and produce that. */
7740 bidi_move_to_visually_next (&it
->bidi_it
);
7742 while (it
->bidi_it
.bytepos
!= orig_bytepos
7743 && it
->bidi_it
.charpos
< eob
);
7746 /* Adjust IT's position information to where we ended up. */
7747 if (STRINGP (it
->string
))
7749 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7750 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7754 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7755 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7758 if (STRINGP (it
->string
) || !it
->s
)
7760 ptrdiff_t stop
, charpos
, bytepos
;
7762 if (STRINGP (it
->string
))
7765 stop
= SCHARS (it
->string
);
7766 if (stop
> it
->end_charpos
)
7767 stop
= it
->end_charpos
;
7768 charpos
= IT_STRING_CHARPOS (*it
);
7769 bytepos
= IT_STRING_BYTEPOS (*it
);
7773 stop
= it
->end_charpos
;
7774 charpos
= IT_CHARPOS (*it
);
7775 bytepos
= IT_BYTEPOS (*it
);
7777 if (it
->bidi_it
.scan_dir
< 0)
7779 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
, stop
,
7784 /* Load IT with the next display element from Lisp string IT->string.
7785 IT->current.string_pos is the current position within the string.
7786 If IT->current.overlay_string_index >= 0, the Lisp string is an
7790 next_element_from_string (struct it
*it
)
7792 struct text_pos position
;
7794 eassert (STRINGP (it
->string
));
7795 eassert (!it
->bidi_p
|| EQ (it
->string
, it
->bidi_it
.string
.lstring
));
7796 eassert (IT_STRING_CHARPOS (*it
) >= 0);
7797 position
= it
->current
.string_pos
;
7799 /* With bidi reordering, the character to display might not be the
7800 character at IT_STRING_CHARPOS. BIDI_IT.FIRST_ELT non-zero means
7801 that we were reseat()ed to a new string, whose paragraph
7802 direction is not known. */
7803 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7805 get_visually_first_element (it
);
7806 SET_TEXT_POS (position
, IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
));
7809 /* Time to check for invisible text? */
7810 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
7812 if (IT_STRING_CHARPOS (*it
) >= it
->stop_charpos
)
7815 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7816 || IT_STRING_CHARPOS (*it
) == it
->stop_charpos
))
7818 /* With bidi non-linear iteration, we could find
7819 ourselves far beyond the last computed stop_charpos,
7820 with several other stop positions in between that we
7821 missed. Scan them all now, in buffer's logical
7822 order, until we find and handle the last stop_charpos
7823 that precedes our current position. */
7824 handle_stop_backwards (it
, it
->stop_charpos
);
7825 return GET_NEXT_DISPLAY_ELEMENT (it
);
7831 /* Take note of the stop position we just moved
7832 across, for when we will move back across it. */
7833 it
->prev_stop
= it
->stop_charpos
;
7834 /* If we are at base paragraph embedding level, take
7835 note of the last stop position seen at this
7837 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7838 it
->base_level_stop
= it
->stop_charpos
;
7842 /* Since a handler may have changed IT->method, we must
7844 return GET_NEXT_DISPLAY_ELEMENT (it
);
7848 /* If we are before prev_stop, we may have overstepped
7849 on our way backwards a stop_pos, and if so, we need
7850 to handle that stop_pos. */
7851 && IT_STRING_CHARPOS (*it
) < it
->prev_stop
7852 /* We can sometimes back up for reasons that have nothing
7853 to do with bidi reordering. E.g., compositions. The
7854 code below is only needed when we are above the base
7855 embedding level, so test for that explicitly. */
7856 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7858 /* If we lost track of base_level_stop, we have no better
7859 place for handle_stop_backwards to start from than string
7860 beginning. This happens, e.g., when we were reseated to
7861 the previous screenful of text by vertical-motion. */
7862 if (it
->base_level_stop
<= 0
7863 || IT_STRING_CHARPOS (*it
) < it
->base_level_stop
)
7864 it
->base_level_stop
= 0;
7865 handle_stop_backwards (it
, it
->base_level_stop
);
7866 return GET_NEXT_DISPLAY_ELEMENT (it
);
7870 if (it
->current
.overlay_string_index
>= 0)
7872 /* Get the next character from an overlay string. In overlay
7873 strings, there is no field width or padding with spaces to
7875 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7880 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7881 IT_STRING_BYTEPOS (*it
),
7882 it
->bidi_it
.scan_dir
< 0
7884 : SCHARS (it
->string
))
7885 && next_element_from_composition (it
))
7889 else if (STRING_MULTIBYTE (it
->string
))
7891 const unsigned char *s
= (SDATA (it
->string
)
7892 + IT_STRING_BYTEPOS (*it
));
7893 it
->c
= string_char_and_length (s
, &it
->len
);
7897 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7903 /* Get the next character from a Lisp string that is not an
7904 overlay string. Such strings come from the mode line, for
7905 example. We may have to pad with spaces, or truncate the
7906 string. See also next_element_from_c_string. */
7907 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7912 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
7914 /* Pad with spaces. */
7915 it
->c
= ' ', it
->len
= 1;
7916 CHARPOS (position
) = BYTEPOS (position
) = -1;
7918 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7919 IT_STRING_BYTEPOS (*it
),
7920 it
->bidi_it
.scan_dir
< 0
7922 : it
->string_nchars
)
7923 && next_element_from_composition (it
))
7927 else if (STRING_MULTIBYTE (it
->string
))
7929 const unsigned char *s
= (SDATA (it
->string
)
7930 + IT_STRING_BYTEPOS (*it
));
7931 it
->c
= string_char_and_length (s
, &it
->len
);
7935 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7940 /* Record what we have and where it came from. */
7941 it
->what
= IT_CHARACTER
;
7942 it
->object
= it
->string
;
7943 it
->position
= position
;
7948 /* Load IT with next display element from C string IT->s.
7949 IT->string_nchars is the maximum number of characters to return
7950 from the string. IT->end_charpos may be greater than
7951 IT->string_nchars when this function is called, in which case we
7952 may have to return padding spaces. Value is zero if end of string
7953 reached, including padding spaces. */
7956 next_element_from_c_string (struct it
*it
)
7958 bool success_p
= true;
7961 eassert (!it
->bidi_p
|| it
->s
== it
->bidi_it
.string
.s
);
7962 it
->what
= IT_CHARACTER
;
7963 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
7966 /* With bidi reordering, the character to display might not be the
7967 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7968 we were reseated to a new string, whose paragraph direction is
7970 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7971 get_visually_first_element (it
);
7973 /* IT's position can be greater than IT->string_nchars in case a
7974 field width or precision has been specified when the iterator was
7976 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7978 /* End of the game. */
7982 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
7984 /* Pad with spaces. */
7985 it
->c
= ' ', it
->len
= 1;
7986 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
7988 else if (it
->multibyte_p
)
7989 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
), &it
->len
);
7991 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
7997 /* Set up IT to return characters from an ellipsis, if appropriate.
7998 The definition of the ellipsis glyphs may come from a display table
7999 entry. This function fills IT with the first glyph from the
8000 ellipsis if an ellipsis is to be displayed. */
8003 next_element_from_ellipsis (struct it
*it
)
8005 if (it
->selective_display_ellipsis_p
)
8006 setup_for_ellipsis (it
, it
->len
);
8009 /* The face at the current position may be different from the
8010 face we find after the invisible text. Remember what it
8011 was in IT->saved_face_id, and signal that it's there by
8012 setting face_before_selective_p. */
8013 it
->saved_face_id
= it
->face_id
;
8014 it
->method
= GET_FROM_BUFFER
;
8015 it
->object
= it
->w
->contents
;
8016 reseat_at_next_visible_line_start (it
, 1);
8017 it
->face_before_selective_p
= true;
8020 return GET_NEXT_DISPLAY_ELEMENT (it
);
8024 /* Deliver an image display element. The iterator IT is already
8025 filled with image information (done in handle_display_prop). Value
8030 next_element_from_image (struct it
*it
)
8032 it
->what
= IT_IMAGE
;
8033 it
->ignore_overlay_strings_at_pos_p
= 0;
8038 /* Fill iterator IT with next display element from a stretch glyph
8039 property. IT->object is the value of the text property. Value is
8043 next_element_from_stretch (struct it
*it
)
8045 it
->what
= IT_STRETCH
;
8049 /* Scan backwards from IT's current position until we find a stop
8050 position, or until BEGV. This is called when we find ourself
8051 before both the last known prev_stop and base_level_stop while
8052 reordering bidirectional text. */
8055 compute_stop_pos_backwards (struct it
*it
)
8057 const int SCAN_BACK_LIMIT
= 1000;
8058 struct text_pos pos
;
8059 struct display_pos save_current
= it
->current
;
8060 struct text_pos save_position
= it
->position
;
8061 ptrdiff_t charpos
= IT_CHARPOS (*it
);
8062 ptrdiff_t where_we_are
= charpos
;
8063 ptrdiff_t save_stop_pos
= it
->stop_charpos
;
8064 ptrdiff_t save_end_pos
= it
->end_charpos
;
8066 eassert (NILP (it
->string
) && !it
->s
);
8067 eassert (it
->bidi_p
);
8071 it
->end_charpos
= min (charpos
+ 1, ZV
);
8072 charpos
= max (charpos
- SCAN_BACK_LIMIT
, BEGV
);
8073 SET_TEXT_POS (pos
, charpos
, CHAR_TO_BYTE (charpos
));
8074 reseat_1 (it
, pos
, 0);
8075 compute_stop_pos (it
);
8076 /* We must advance forward, right? */
8077 if (it
->stop_charpos
<= charpos
)
8080 while (charpos
> BEGV
&& it
->stop_charpos
>= it
->end_charpos
);
8082 if (it
->stop_charpos
<= where_we_are
)
8083 it
->prev_stop
= it
->stop_charpos
;
8085 it
->prev_stop
= BEGV
;
8087 it
->current
= save_current
;
8088 it
->position
= save_position
;
8089 it
->stop_charpos
= save_stop_pos
;
8090 it
->end_charpos
= save_end_pos
;
8093 /* Scan forward from CHARPOS in the current buffer/string, until we
8094 find a stop position > current IT's position. Then handle the stop
8095 position before that. This is called when we bump into a stop
8096 position while reordering bidirectional text. CHARPOS should be
8097 the last previously processed stop_pos (or BEGV/0, if none were
8098 processed yet) whose position is less that IT's current
8102 handle_stop_backwards (struct it
*it
, ptrdiff_t charpos
)
8104 int bufp
= !STRINGP (it
->string
);
8105 ptrdiff_t where_we_are
= (bufp
? IT_CHARPOS (*it
) : IT_STRING_CHARPOS (*it
));
8106 struct display_pos save_current
= it
->current
;
8107 struct text_pos save_position
= it
->position
;
8108 struct text_pos pos1
;
8109 ptrdiff_t next_stop
;
8111 /* Scan in strict logical order. */
8112 eassert (it
->bidi_p
);
8116 it
->prev_stop
= charpos
;
8119 SET_TEXT_POS (pos1
, charpos
, CHAR_TO_BYTE (charpos
));
8120 reseat_1 (it
, pos1
, 0);
8123 it
->current
.string_pos
= string_pos (charpos
, it
->string
);
8124 compute_stop_pos (it
);
8125 /* We must advance forward, right? */
8126 if (it
->stop_charpos
<= it
->prev_stop
)
8128 charpos
= it
->stop_charpos
;
8130 while (charpos
<= where_we_are
);
8133 it
->current
= save_current
;
8134 it
->position
= save_position
;
8135 next_stop
= it
->stop_charpos
;
8136 it
->stop_charpos
= it
->prev_stop
;
8138 it
->stop_charpos
= next_stop
;
8141 /* Load IT with the next display element from current_buffer. Value
8142 is zero if end of buffer reached. IT->stop_charpos is the next
8143 position at which to stop and check for text properties or buffer
8147 next_element_from_buffer (struct it
*it
)
8149 bool success_p
= true;
8151 eassert (IT_CHARPOS (*it
) >= BEGV
);
8152 eassert (NILP (it
->string
) && !it
->s
);
8153 eassert (!it
->bidi_p
8154 || (EQ (it
->bidi_it
.string
.lstring
, Qnil
)
8155 && it
->bidi_it
.string
.s
== NULL
));
8157 /* With bidi reordering, the character to display might not be the
8158 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
8159 we were reseat()ed to a new buffer position, which is potentially
8160 a different paragraph. */
8161 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
8163 get_visually_first_element (it
);
8164 SET_TEXT_POS (it
->position
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8167 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
8169 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
8171 int overlay_strings_follow_p
;
8173 /* End of the game, except when overlay strings follow that
8174 haven't been returned yet. */
8175 if (it
->overlay_strings_at_end_processed_p
)
8176 overlay_strings_follow_p
= 0;
8179 it
->overlay_strings_at_end_processed_p
= true;
8180 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
8183 if (overlay_strings_follow_p
)
8184 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
8188 it
->position
= it
->current
.pos
;
8192 else if (!(!it
->bidi_p
8193 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
8194 || IT_CHARPOS (*it
) == it
->stop_charpos
))
8196 /* With bidi non-linear iteration, we could find ourselves
8197 far beyond the last computed stop_charpos, with several
8198 other stop positions in between that we missed. Scan
8199 them all now, in buffer's logical order, until we find
8200 and handle the last stop_charpos that precedes our
8201 current position. */
8202 handle_stop_backwards (it
, it
->stop_charpos
);
8203 return GET_NEXT_DISPLAY_ELEMENT (it
);
8209 /* Take note of the stop position we just moved across,
8210 for when we will move back across it. */
8211 it
->prev_stop
= it
->stop_charpos
;
8212 /* If we are at base paragraph embedding level, take
8213 note of the last stop position seen at this
8215 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
8216 it
->base_level_stop
= it
->stop_charpos
;
8219 return GET_NEXT_DISPLAY_ELEMENT (it
);
8223 /* If we are before prev_stop, we may have overstepped on
8224 our way backwards a stop_pos, and if so, we need to
8225 handle that stop_pos. */
8226 && IT_CHARPOS (*it
) < it
->prev_stop
8227 /* We can sometimes back up for reasons that have nothing
8228 to do with bidi reordering. E.g., compositions. The
8229 code below is only needed when we are above the base
8230 embedding level, so test for that explicitly. */
8231 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
8233 if (it
->base_level_stop
<= 0
8234 || IT_CHARPOS (*it
) < it
->base_level_stop
)
8236 /* If we lost track of base_level_stop, we need to find
8237 prev_stop by looking backwards. This happens, e.g., when
8238 we were reseated to the previous screenful of text by
8240 it
->base_level_stop
= BEGV
;
8241 compute_stop_pos_backwards (it
);
8242 handle_stop_backwards (it
, it
->prev_stop
);
8245 handle_stop_backwards (it
, it
->base_level_stop
);
8246 return GET_NEXT_DISPLAY_ELEMENT (it
);
8250 /* No face changes, overlays etc. in sight, so just return a
8251 character from current_buffer. */
8255 /* Maybe run the redisplay end trigger hook. Performance note:
8256 This doesn't seem to cost measurable time. */
8257 if (it
->redisplay_end_trigger_charpos
8259 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
8260 run_redisplay_end_trigger_hook (it
);
8262 stop
= it
->bidi_it
.scan_dir
< 0 ? -1 : it
->end_charpos
;
8263 if (CHAR_COMPOSED_P (it
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
8265 && next_element_from_composition (it
))
8270 /* Get the next character, maybe multibyte. */
8271 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
8272 if (it
->multibyte_p
&& !ASCII_CHAR_P (*p
))
8273 it
->c
= STRING_CHAR_AND_LENGTH (p
, it
->len
);
8275 it
->c
= *p
, it
->len
= 1;
8277 /* Record what we have and where it came from. */
8278 it
->what
= IT_CHARACTER
;
8279 it
->object
= it
->w
->contents
;
8280 it
->position
= it
->current
.pos
;
8282 /* Normally we return the character found above, except when we
8283 really want to return an ellipsis for selective display. */
8288 /* A value of selective > 0 means hide lines indented more
8289 than that number of columns. */
8290 if (it
->selective
> 0
8291 && IT_CHARPOS (*it
) + 1 < ZV
8292 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
8293 IT_BYTEPOS (*it
) + 1,
8296 success_p
= next_element_from_ellipsis (it
);
8297 it
->dpvec_char_len
= -1;
8300 else if (it
->c
== '\r' && it
->selective
== -1)
8302 /* A value of selective == -1 means that everything from the
8303 CR to the end of the line is invisible, with maybe an
8304 ellipsis displayed for it. */
8305 success_p
= next_element_from_ellipsis (it
);
8306 it
->dpvec_char_len
= -1;
8311 /* Value is zero if end of buffer reached. */
8312 eassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
8317 /* Run the redisplay end trigger hook for IT. */
8320 run_redisplay_end_trigger_hook (struct it
*it
)
8322 Lisp_Object args
[3];
8324 /* IT->glyph_row should be non-null, i.e. we should be actually
8325 displaying something, or otherwise we should not run the hook. */
8326 eassert (it
->glyph_row
);
8328 /* Set up hook arguments. */
8329 args
[0] = Qredisplay_end_trigger_functions
;
8330 args
[1] = it
->window
;
8331 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
8332 it
->redisplay_end_trigger_charpos
= 0;
8334 /* Since we are *trying* to run these functions, don't try to run
8335 them again, even if they get an error. */
8336 wset_redisplay_end_trigger (it
->w
, Qnil
);
8337 Frun_hook_with_args (3, args
);
8339 /* Notice if it changed the face of the character we are on. */
8340 handle_face_prop (it
);
8344 /* Deliver a composition display element. Unlike the other
8345 next_element_from_XXX, this function is not registered in the array
8346 get_next_element[]. It is called from next_element_from_buffer and
8347 next_element_from_string when necessary. */
8350 next_element_from_composition (struct it
*it
)
8352 it
->what
= IT_COMPOSITION
;
8353 it
->len
= it
->cmp_it
.nbytes
;
8354 if (STRINGP (it
->string
))
8358 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8359 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8362 it
->position
= it
->current
.string_pos
;
8363 it
->object
= it
->string
;
8364 it
->c
= composition_update_it (&it
->cmp_it
, IT_STRING_CHARPOS (*it
),
8365 IT_STRING_BYTEPOS (*it
), it
->string
);
8371 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8372 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8375 if (it
->bidi_it
.new_paragraph
)
8376 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
8377 /* Resync the bidi iterator with IT's new position.
8378 FIXME: this doesn't support bidirectional text. */
8379 while (it
->bidi_it
.charpos
< IT_CHARPOS (*it
))
8380 bidi_move_to_visually_next (&it
->bidi_it
);
8384 it
->position
= it
->current
.pos
;
8385 it
->object
= it
->w
->contents
;
8386 it
->c
= composition_update_it (&it
->cmp_it
, IT_CHARPOS (*it
),
8387 IT_BYTEPOS (*it
), Qnil
);
8394 /***********************************************************************
8395 Moving an iterator without producing glyphs
8396 ***********************************************************************/
8398 /* Check if iterator is at a position corresponding to a valid buffer
8399 position after some move_it_ call. */
8401 #define IT_POS_VALID_AFTER_MOVE_P(it) \
8402 ((it)->method == GET_FROM_STRING \
8403 ? IT_STRING_CHARPOS (*it) == 0 \
8407 /* Move iterator IT to a specified buffer or X position within one
8408 line on the display without producing glyphs.
8410 OP should be a bit mask including some or all of these bits:
8411 MOVE_TO_X: Stop upon reaching x-position TO_X.
8412 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
8413 Regardless of OP's value, stop upon reaching the end of the display line.
8415 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
8416 This means, in particular, that TO_X includes window's horizontal
8419 The return value has several possible values that
8420 say what condition caused the scan to stop:
8422 MOVE_POS_MATCH_OR_ZV
8423 - when TO_POS or ZV was reached.
8426 -when TO_X was reached before TO_POS or ZV were reached.
8429 - when we reached the end of the display area and the line must
8433 - when we reached the end of the display area and the line is
8437 - when we stopped at a line end, i.e. a newline or a CR and selective
8440 static enum move_it_result
8441 move_it_in_display_line_to (struct it
*it
,
8442 ptrdiff_t to_charpos
, int to_x
,
8443 enum move_operation_enum op
)
8445 enum move_it_result result
= MOVE_UNDEFINED
;
8446 struct glyph_row
*saved_glyph_row
;
8447 struct it wrap_it
, atpos_it
, atx_it
, ppos_it
;
8448 void *wrap_data
= NULL
, *atpos_data
= NULL
, *atx_data
= NULL
;
8449 void *ppos_data
= NULL
;
8451 enum it_method prev_method
= it
->method
;
8452 ptrdiff_t closest_pos
IF_LINT (= 0), prev_pos
= IT_CHARPOS (*it
);
8453 int saw_smaller_pos
= prev_pos
< to_charpos
;
8455 /* Don't produce glyphs in produce_glyphs. */
8456 saved_glyph_row
= it
->glyph_row
;
8457 it
->glyph_row
= NULL
;
8459 /* Use wrap_it to save a copy of IT wherever a word wrap could
8460 occur. Use atpos_it to save a copy of IT at the desired buffer
8461 position, if found, so that we can scan ahead and check if the
8462 word later overshoots the window edge. Use atx_it similarly, for
8468 /* Use ppos_it under bidi reordering to save a copy of IT for the
8469 initial position. We restore that position in IT when we have
8470 scanned the entire display line without finding a match for
8471 TO_CHARPOS and all the character positions are greater than
8472 TO_CHARPOS. We then restart the scan from the initial position,
8473 and stop at CLOSEST_POS, which is a position > TO_CHARPOS that is
8474 the closest to TO_CHARPOS. */
8477 if ((op
& MOVE_TO_POS
) && IT_CHARPOS (*it
) >= to_charpos
)
8479 SAVE_IT (ppos_it
, *it
, ppos_data
);
8480 closest_pos
= IT_CHARPOS (*it
);
8486 #define BUFFER_POS_REACHED_P() \
8487 ((op & MOVE_TO_POS) != 0 \
8488 && BUFFERP (it->object) \
8489 && (IT_CHARPOS (*it) == to_charpos \
8491 || BIDI_AT_BASE_LEVEL (it->bidi_it)) \
8492 && IT_CHARPOS (*it) > to_charpos) \
8493 || (it->what == IT_COMPOSITION \
8494 && ((IT_CHARPOS (*it) > to_charpos \
8495 && to_charpos >= it->cmp_it.charpos) \
8496 || (IT_CHARPOS (*it) < to_charpos \
8497 && to_charpos <= it->cmp_it.charpos)))) \
8498 && (it->method == GET_FROM_BUFFER \
8499 || (it->method == GET_FROM_DISPLAY_VECTOR \
8500 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
8502 /* If there's a line-/wrap-prefix, handle it. */
8503 if (it
->hpos
== 0 && it
->method
== GET_FROM_BUFFER
8504 && it
->current_y
< it
->last_visible_y
)
8505 handle_line_prefix (it
);
8507 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8508 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8512 int x
, i
, ascent
= 0, descent
= 0;
8514 /* Utility macro to reset an iterator with x, ascent, and descent. */
8515 #define IT_RESET_X_ASCENT_DESCENT(IT) \
8516 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
8517 (IT)->max_descent = descent)
8519 /* Stop if we move beyond TO_CHARPOS (after an image or a
8520 display string or stretch glyph). */
8521 if ((op
& MOVE_TO_POS
) != 0
8522 && BUFFERP (it
->object
)
8523 && it
->method
== GET_FROM_BUFFER
8525 /* When the iterator is at base embedding level, we
8526 are guaranteed that characters are delivered for
8527 display in strictly increasing order of their
8528 buffer positions. */
8529 || BIDI_AT_BASE_LEVEL (it
->bidi_it
))
8530 && IT_CHARPOS (*it
) > to_charpos
)
8532 && (prev_method
== GET_FROM_IMAGE
8533 || prev_method
== GET_FROM_STRETCH
8534 || prev_method
== GET_FROM_STRING
)
8535 /* Passed TO_CHARPOS from left to right. */
8536 && ((prev_pos
< to_charpos
8537 && IT_CHARPOS (*it
) > to_charpos
)
8538 /* Passed TO_CHARPOS from right to left. */
8539 || (prev_pos
> to_charpos
8540 && IT_CHARPOS (*it
) < to_charpos
)))))
8542 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8544 result
= MOVE_POS_MATCH_OR_ZV
;
8547 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8548 /* If wrap_it is valid, the current position might be in a
8549 word that is wrapped. So, save the iterator in
8550 atpos_it and continue to see if wrapping happens. */
8551 SAVE_IT (atpos_it
, *it
, atpos_data
);
8554 /* Stop when ZV reached.
8555 We used to stop here when TO_CHARPOS reached as well, but that is
8556 too soon if this glyph does not fit on this line. So we handle it
8557 explicitly below. */
8558 if (!get_next_display_element (it
))
8560 result
= MOVE_POS_MATCH_OR_ZV
;
8564 if (it
->line_wrap
== TRUNCATE
)
8566 if (BUFFER_POS_REACHED_P ())
8568 result
= MOVE_POS_MATCH_OR_ZV
;
8574 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
8576 if (IT_DISPLAYING_WHITESPACE (it
))
8580 /* We have reached a glyph that follows one or more
8581 whitespace characters. If the position is
8582 already found, we are done. */
8583 if (atpos_it
.sp
>= 0)
8585 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8586 result
= MOVE_POS_MATCH_OR_ZV
;
8591 RESTORE_IT (it
, &atx_it
, atx_data
);
8592 result
= MOVE_X_REACHED
;
8595 /* Otherwise, we can wrap here. */
8596 SAVE_IT (wrap_it
, *it
, wrap_data
);
8602 /* Remember the line height for the current line, in case
8603 the next element doesn't fit on the line. */
8604 ascent
= it
->max_ascent
;
8605 descent
= it
->max_descent
;
8607 /* The call to produce_glyphs will get the metrics of the
8608 display element IT is loaded with. Record the x-position
8609 before this display element, in case it doesn't fit on the
8613 PRODUCE_GLYPHS (it
);
8615 if (it
->area
!= TEXT_AREA
)
8617 prev_method
= it
->method
;
8618 if (it
->method
== GET_FROM_BUFFER
)
8619 prev_pos
= IT_CHARPOS (*it
);
8620 set_iterator_to_next (it
, 1);
8621 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8622 SET_TEXT_POS (this_line_min_pos
,
8623 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8625 && (op
& MOVE_TO_POS
)
8626 && IT_CHARPOS (*it
) > to_charpos
8627 && IT_CHARPOS (*it
) < closest_pos
)
8628 closest_pos
= IT_CHARPOS (*it
);
8632 /* The number of glyphs we get back in IT->nglyphs will normally
8633 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
8634 character on a terminal frame, or (iii) a line end. For the
8635 second case, IT->nglyphs - 1 padding glyphs will be present.
8636 (On X frames, there is only one glyph produced for a
8637 composite character.)
8639 The behavior implemented below means, for continuation lines,
8640 that as many spaces of a TAB as fit on the current line are
8641 displayed there. For terminal frames, as many glyphs of a
8642 multi-glyph character are displayed in the current line, too.
8643 This is what the old redisplay code did, and we keep it that
8644 way. Under X, the whole shape of a complex character must
8645 fit on the line or it will be completely displayed in the
8648 Note that both for tabs and padding glyphs, all glyphs have
8652 /* More than one glyph or glyph doesn't fit on line. All
8653 glyphs have the same width. */
8654 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
8656 int x_before_this_char
= x
;
8657 int hpos_before_this_char
= it
->hpos
;
8659 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
8661 new_x
= x
+ single_glyph_width
;
8663 /* We want to leave anything reaching TO_X to the caller. */
8664 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
8666 if (BUFFER_POS_REACHED_P ())
8668 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8669 goto buffer_pos_reached
;
8670 if (atpos_it
.sp
< 0)
8672 SAVE_IT (atpos_it
, *it
, atpos_data
);
8673 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8678 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8681 result
= MOVE_X_REACHED
;
8686 SAVE_IT (atx_it
, *it
, atx_data
);
8687 IT_RESET_X_ASCENT_DESCENT (&atx_it
);
8692 if (/* Lines are continued. */
8693 it
->line_wrap
!= TRUNCATE
8694 && (/* And glyph doesn't fit on the line. */
8695 new_x
> it
->last_visible_x
8696 /* Or it fits exactly and we're on a window
8698 || (new_x
== it
->last_visible_x
8699 && FRAME_WINDOW_P (it
->f
)
8700 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8701 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8702 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
8704 if (/* IT->hpos == 0 means the very first glyph
8705 doesn't fit on the line, e.g. a wide image. */
8707 || (new_x
== it
->last_visible_x
8708 && FRAME_WINDOW_P (it
->f
)
8709 /* When word-wrap is ON and we have a valid
8710 wrap point, we don't allow the last glyph
8711 to "just barely fit" on the line. */
8712 && (it
->line_wrap
!= WORD_WRAP
8713 || wrap_it
.sp
< 0)))
8716 it
->current_x
= new_x
;
8718 /* The character's last glyph just barely fits
8720 if (i
== it
->nglyphs
- 1)
8722 /* If this is the destination position,
8723 return a position *before* it in this row,
8724 now that we know it fits in this row. */
8725 if (BUFFER_POS_REACHED_P ())
8727 if (it
->line_wrap
!= WORD_WRAP
8730 it
->hpos
= hpos_before_this_char
;
8731 it
->current_x
= x_before_this_char
;
8732 result
= MOVE_POS_MATCH_OR_ZV
;
8735 if (it
->line_wrap
== WORD_WRAP
8738 SAVE_IT (atpos_it
, *it
, atpos_data
);
8739 atpos_it
.current_x
= x_before_this_char
;
8740 atpos_it
.hpos
= hpos_before_this_char
;
8744 prev_method
= it
->method
;
8745 if (it
->method
== GET_FROM_BUFFER
)
8746 prev_pos
= IT_CHARPOS (*it
);
8747 set_iterator_to_next (it
, 1);
8748 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8749 SET_TEXT_POS (this_line_min_pos
,
8750 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8751 /* On graphical terminals, newlines may
8752 "overflow" into the fringe if
8753 overflow-newline-into-fringe is non-nil.
8754 On text terminals, and on graphical
8755 terminals with no right margin, newlines
8756 may overflow into the last glyph on the
8758 if (!FRAME_WINDOW_P (it
->f
)
8760 && it
->bidi_it
.paragraph_dir
== R2L
)
8761 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8762 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8763 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8765 if (!get_next_display_element (it
))
8767 result
= MOVE_POS_MATCH_OR_ZV
;
8770 if (BUFFER_POS_REACHED_P ())
8772 if (ITERATOR_AT_END_OF_LINE_P (it
))
8773 result
= MOVE_POS_MATCH_OR_ZV
;
8775 result
= MOVE_LINE_CONTINUED
;
8778 if (ITERATOR_AT_END_OF_LINE_P (it
)
8779 && (it
->line_wrap
!= WORD_WRAP
8782 result
= MOVE_NEWLINE_OR_CR
;
8789 IT_RESET_X_ASCENT_DESCENT (it
);
8791 if (wrap_it
.sp
>= 0)
8793 RESTORE_IT (it
, &wrap_it
, wrap_data
);
8798 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
8800 result
= MOVE_LINE_CONTINUED
;
8804 if (BUFFER_POS_REACHED_P ())
8806 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8807 goto buffer_pos_reached
;
8808 if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8810 SAVE_IT (atpos_it
, *it
, atpos_data
);
8811 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8815 if (new_x
> it
->first_visible_x
)
8817 /* Glyph is visible. Increment number of glyphs that
8818 would be displayed. */
8823 if (result
!= MOVE_UNDEFINED
)
8826 else if (BUFFER_POS_REACHED_P ())
8829 IT_RESET_X_ASCENT_DESCENT (it
);
8830 result
= MOVE_POS_MATCH_OR_ZV
;
8833 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
8835 /* Stop when TO_X specified and reached. This check is
8836 necessary here because of lines consisting of a line end,
8837 only. The line end will not produce any glyphs and we
8838 would never get MOVE_X_REACHED. */
8839 eassert (it
->nglyphs
== 0);
8840 result
= MOVE_X_REACHED
;
8844 /* Is this a line end? If yes, we're done. */
8845 if (ITERATOR_AT_END_OF_LINE_P (it
))
8847 /* If we are past TO_CHARPOS, but never saw any character
8848 positions smaller than TO_CHARPOS, return
8849 MOVE_POS_MATCH_OR_ZV, like the unidirectional display
8851 if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0)
8853 if (!saw_smaller_pos
&& IT_CHARPOS (*it
) > to_charpos
)
8855 if (closest_pos
< ZV
)
8857 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8858 /* Don't recurse if closest_pos is equal to
8859 to_charpos, since we have just tried that. */
8860 if (closest_pos
!= to_charpos
)
8861 move_it_in_display_line_to (it
, closest_pos
, -1,
8863 result
= MOVE_POS_MATCH_OR_ZV
;
8866 goto buffer_pos_reached
;
8868 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
>= 0
8869 && IT_CHARPOS (*it
) > to_charpos
)
8870 goto buffer_pos_reached
;
8872 result
= MOVE_NEWLINE_OR_CR
;
8875 result
= MOVE_NEWLINE_OR_CR
;
8879 prev_method
= it
->method
;
8880 if (it
->method
== GET_FROM_BUFFER
)
8881 prev_pos
= IT_CHARPOS (*it
);
8882 /* The current display element has been consumed. Advance
8884 set_iterator_to_next (it
, 1);
8885 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8886 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8887 if (IT_CHARPOS (*it
) < to_charpos
)
8888 saw_smaller_pos
= 1;
8890 && (op
& MOVE_TO_POS
)
8891 && IT_CHARPOS (*it
) >= to_charpos
8892 && IT_CHARPOS (*it
) < closest_pos
)
8893 closest_pos
= IT_CHARPOS (*it
);
8895 /* Stop if lines are truncated and IT's current x-position is
8896 past the right edge of the window now. */
8897 if (it
->line_wrap
== TRUNCATE
8898 && it
->current_x
>= it
->last_visible_x
)
8900 if (!FRAME_WINDOW_P (it
->f
)
8901 || ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8902 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8903 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8904 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8908 if ((at_eob_p
= !get_next_display_element (it
))
8909 || BUFFER_POS_REACHED_P ()
8910 /* If we are past TO_CHARPOS, but never saw any
8911 character positions smaller than TO_CHARPOS,
8912 return MOVE_POS_MATCH_OR_ZV, like the
8913 unidirectional display did. */
8914 || (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8916 && IT_CHARPOS (*it
) > to_charpos
))
8919 && !BUFFER_POS_REACHED_P ()
8920 && !at_eob_p
&& closest_pos
< ZV
)
8922 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8923 if (closest_pos
!= to_charpos
)
8924 move_it_in_display_line_to (it
, closest_pos
, -1,
8927 result
= MOVE_POS_MATCH_OR_ZV
;
8930 if (ITERATOR_AT_END_OF_LINE_P (it
))
8932 result
= MOVE_NEWLINE_OR_CR
;
8936 else if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8938 && IT_CHARPOS (*it
) > to_charpos
)
8940 if (closest_pos
< ZV
)
8942 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8943 if (closest_pos
!= to_charpos
)
8944 move_it_in_display_line_to (it
, closest_pos
, -1,
8947 result
= MOVE_POS_MATCH_OR_ZV
;
8950 result
= MOVE_LINE_TRUNCATED
;
8953 #undef IT_RESET_X_ASCENT_DESCENT
8956 #undef BUFFER_POS_REACHED_P
8958 /* If we scanned beyond to_pos and didn't find a point to wrap at,
8959 restore the saved iterator. */
8960 if (atpos_it
.sp
>= 0)
8961 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8962 else if (atx_it
.sp
>= 0)
8963 RESTORE_IT (it
, &atx_it
, atx_data
);
8968 bidi_unshelve_cache (atpos_data
, 1);
8970 bidi_unshelve_cache (atx_data
, 1);
8972 bidi_unshelve_cache (wrap_data
, 1);
8974 bidi_unshelve_cache (ppos_data
, 1);
8976 /* Restore the iterator settings altered at the beginning of this
8978 it
->glyph_row
= saved_glyph_row
;
8982 /* For external use. */
8984 move_it_in_display_line (struct it
*it
,
8985 ptrdiff_t to_charpos
, int to_x
,
8986 enum move_operation_enum op
)
8988 if (it
->line_wrap
== WORD_WRAP
8989 && (op
& MOVE_TO_X
))
8992 void *save_data
= NULL
;
8995 SAVE_IT (save_it
, *it
, save_data
);
8996 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8997 /* When word-wrap is on, TO_X may lie past the end
8998 of a wrapped line. Then it->current is the
8999 character on the next line, so backtrack to the
9000 space before the wrap point. */
9001 if (skip
== MOVE_LINE_CONTINUED
)
9003 int prev_x
= max (it
->current_x
- 1, 0);
9004 RESTORE_IT (it
, &save_it
, save_data
);
9005 move_it_in_display_line_to
9006 (it
, -1, prev_x
, MOVE_TO_X
);
9009 bidi_unshelve_cache (save_data
, 1);
9012 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
9016 /* Move IT forward until it satisfies one or more of the criteria in
9017 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
9019 OP is a bit-mask that specifies where to stop, and in particular,
9020 which of those four position arguments makes a difference. See the
9021 description of enum move_operation_enum.
9023 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
9024 screen line, this function will set IT to the next position that is
9025 displayed to the right of TO_CHARPOS on the screen.
9027 Return the maximum pixel length of any line scanned but never more
9028 than it.last_visible_x. */
9031 move_it_to (struct it
*it
, ptrdiff_t to_charpos
, int to_x
, int to_y
, int to_vpos
, int op
)
9033 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
9034 int line_height
, line_start_x
= 0, reached
= 0;
9035 int max_current_x
= 0;
9036 void *backup_data
= NULL
;
9040 if (op
& MOVE_TO_VPOS
)
9042 /* If no TO_CHARPOS and no TO_X specified, stop at the
9043 start of the line TO_VPOS. */
9044 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
9046 if (it
->vpos
== to_vpos
)
9052 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
9056 /* TO_VPOS >= 0 means stop at TO_X in the line at
9057 TO_VPOS, or at TO_POS, whichever comes first. */
9058 if (it
->vpos
== to_vpos
)
9064 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
9066 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
9071 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
9073 /* We have reached TO_X but not in the line we want. */
9074 skip
= move_it_in_display_line_to (it
, to_charpos
,
9076 if (skip
== MOVE_POS_MATCH_OR_ZV
)
9084 else if (op
& MOVE_TO_Y
)
9086 struct it it_backup
;
9088 if (it
->line_wrap
== WORD_WRAP
)
9089 SAVE_IT (it_backup
, *it
, backup_data
);
9091 /* TO_Y specified means stop at TO_X in the line containing
9092 TO_Y---or at TO_CHARPOS if this is reached first. The
9093 problem is that we can't really tell whether the line
9094 contains TO_Y before we have completely scanned it, and
9095 this may skip past TO_X. What we do is to first scan to
9098 If TO_X is not specified, use a TO_X of zero. The reason
9099 is to make the outcome of this function more predictable.
9100 If we didn't use TO_X == 0, we would stop at the end of
9101 the line which is probably not what a caller would expect
9103 skip
= move_it_in_display_line_to
9104 (it
, to_charpos
, ((op
& MOVE_TO_X
) ? to_x
: 0),
9105 (MOVE_TO_X
| (op
& MOVE_TO_POS
)));
9107 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
9108 if (skip
== MOVE_POS_MATCH_OR_ZV
)
9110 else if (skip
== MOVE_X_REACHED
)
9112 /* If TO_X was reached, we want to know whether TO_Y is
9113 in the line. We know this is the case if the already
9114 scanned glyphs make the line tall enough. Otherwise,
9115 we must check by scanning the rest of the line. */
9116 line_height
= it
->max_ascent
+ it
->max_descent
;
9117 if (to_y
>= it
->current_y
9118 && to_y
< it
->current_y
+ line_height
)
9123 SAVE_IT (it_backup
, *it
, backup_data
);
9124 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
9125 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
9127 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
9128 line_height
= it
->max_ascent
+ it
->max_descent
;
9129 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
9131 if (to_y
>= it
->current_y
9132 && to_y
< it
->current_y
+ line_height
)
9134 /* If TO_Y is in this line and TO_X was reached
9135 above, we scanned too far. We have to restore
9136 IT's settings to the ones before skipping. But
9137 keep the more accurate values of max_ascent and
9138 max_descent we've found while skipping the rest
9139 of the line, for the sake of callers, such as
9140 pos_visible_p, that need to know the line
9142 int max_ascent
= it
->max_ascent
;
9143 int max_descent
= it
->max_descent
;
9145 RESTORE_IT (it
, &it_backup
, backup_data
);
9146 it
->max_ascent
= max_ascent
;
9147 it
->max_descent
= max_descent
;
9153 if (skip
== MOVE_POS_MATCH_OR_ZV
)
9159 /* Check whether TO_Y is in this line. */
9160 line_height
= it
->max_ascent
+ it
->max_descent
;
9161 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
9163 if (to_y
>= it
->current_y
9164 && to_y
< it
->current_y
+ line_height
)
9166 if (to_y
> it
->current_y
)
9167 max_current_x
= max (it
->current_x
, max_current_x
);
9169 /* When word-wrap is on, TO_X may lie past the end
9170 of a wrapped line. Then it->current is the
9171 character on the next line, so backtrack to the
9172 space before the wrap point. */
9173 if (skip
== MOVE_LINE_CONTINUED
9174 && it
->line_wrap
== WORD_WRAP
)
9176 int prev_x
= max (it
->current_x
- 1, 0);
9177 RESTORE_IT (it
, &it_backup
, backup_data
);
9178 skip
= move_it_in_display_line_to
9179 (it
, -1, prev_x
, MOVE_TO_X
);
9188 max_current_x
= max (it
->current_x
, max_current_x
);
9192 else if (BUFFERP (it
->object
)
9193 && (it
->method
== GET_FROM_BUFFER
9194 || it
->method
== GET_FROM_STRETCH
)
9195 && IT_CHARPOS (*it
) >= to_charpos
9196 /* Under bidi iteration, a call to set_iterator_to_next
9197 can scan far beyond to_charpos if the initial
9198 portion of the next line needs to be reordered. In
9199 that case, give move_it_in_display_line_to another
9202 && it
->bidi_it
.scan_dir
== -1))
9203 skip
= MOVE_POS_MATCH_OR_ZV
;
9205 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
9209 case MOVE_POS_MATCH_OR_ZV
:
9210 max_current_x
= max (it
->current_x
, max_current_x
);
9214 case MOVE_NEWLINE_OR_CR
:
9215 max_current_x
= max (it
->current_x
, max_current_x
);
9216 set_iterator_to_next (it
, 1);
9217 it
->continuation_lines_width
= 0;
9220 case MOVE_LINE_TRUNCATED
:
9221 max_current_x
= it
->last_visible_x
;
9222 it
->continuation_lines_width
= 0;
9223 reseat_at_next_visible_line_start (it
, 0);
9224 if ((op
& MOVE_TO_POS
) != 0
9225 && IT_CHARPOS (*it
) > to_charpos
)
9232 case MOVE_LINE_CONTINUED
:
9233 max_current_x
= it
->last_visible_x
;
9234 /* For continued lines ending in a tab, some of the glyphs
9235 associated with the tab are displayed on the current
9236 line. Since it->current_x does not include these glyphs,
9237 we use it->last_visible_x instead. */
9240 it
->continuation_lines_width
+= it
->last_visible_x
;
9241 /* When moving by vpos, ensure that the iterator really
9242 advances to the next line (bug#847, bug#969). Fixme:
9243 do we need to do this in other circumstances? */
9244 if (it
->current_x
!= it
->last_visible_x
9245 && (op
& MOVE_TO_VPOS
)
9246 && !(op
& (MOVE_TO_X
| MOVE_TO_POS
)))
9248 line_start_x
= it
->current_x
+ it
->pixel_width
9249 - it
->last_visible_x
;
9250 set_iterator_to_next (it
, 0);
9254 it
->continuation_lines_width
+= it
->current_x
;
9261 /* Reset/increment for the next run. */
9262 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
9263 it
->current_x
= line_start_x
;
9266 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
9268 last_height
= it
->max_ascent
+ it
->max_descent
;
9269 it
->max_ascent
= it
->max_descent
= 0;
9274 /* On text terminals, we may stop at the end of a line in the middle
9275 of a multi-character glyph. If the glyph itself is continued,
9276 i.e. it is actually displayed on the next line, don't treat this
9277 stopping point as valid; move to the next line instead (unless
9278 that brings us offscreen). */
9279 if (!FRAME_WINDOW_P (it
->f
)
9281 && IT_CHARPOS (*it
) == to_charpos
9282 && it
->what
== IT_CHARACTER
9284 && it
->line_wrap
== WINDOW_WRAP
9285 && it
->current_x
== it
->last_visible_x
- 1
9288 && it
->vpos
< it
->w
->window_end_vpos
)
9290 it
->continuation_lines_width
+= it
->current_x
;
9291 it
->current_x
= it
->hpos
= it
->max_ascent
= it
->max_descent
= 0;
9292 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
9294 last_height
= it
->max_ascent
+ it
->max_descent
;
9298 bidi_unshelve_cache (backup_data
, 1);
9300 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
9302 return max_current_x
;
9306 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
9308 If DY > 0, move IT backward at least that many pixels. DY = 0
9309 means move IT backward to the preceding line start or BEGV. This
9310 function may move over more than DY pixels if IT->current_y - DY
9311 ends up in the middle of a line; in this case IT->current_y will be
9312 set to the top of the line moved to. */
9315 move_it_vertically_backward (struct it
*it
, int dy
)
9319 void *it2data
= NULL
, *it3data
= NULL
;
9320 ptrdiff_t start_pos
;
9322 = (it
->last_visible_x
- it
->first_visible_x
) / FRAME_COLUMN_WIDTH (it
->f
);
9323 ptrdiff_t pos_limit
;
9328 start_pos
= IT_CHARPOS (*it
);
9330 /* Estimate how many newlines we must move back. */
9331 nlines
= max (1, dy
/ default_line_pixel_height (it
->w
));
9332 if (it
->line_wrap
== TRUNCATE
)
9335 pos_limit
= max (start_pos
- nlines
* nchars_per_row
, BEGV
);
9337 /* Set the iterator's position that many lines back. But don't go
9338 back more than NLINES full screen lines -- this wins a day with
9339 buffers which have very long lines. */
9340 while (nlines
-- && IT_CHARPOS (*it
) > pos_limit
)
9341 back_to_previous_visible_line_start (it
);
9343 /* Reseat the iterator here. When moving backward, we don't want
9344 reseat to skip forward over invisible text, set up the iterator
9345 to deliver from overlay strings at the new position etc. So,
9346 use reseat_1 here. */
9347 reseat_1 (it
, it
->current
.pos
, 1);
9349 /* We are now surely at a line start. */
9350 it
->current_x
= it
->hpos
= 0; /* FIXME: this is incorrect when bidi
9351 reordering is in effect. */
9352 it
->continuation_lines_width
= 0;
9354 /* Move forward and see what y-distance we moved. First move to the
9355 start of the next line so that we get its height. We need this
9356 height to be able to tell whether we reached the specified
9358 SAVE_IT (it2
, *it
, it2data
);
9359 it2
.max_ascent
= it2
.max_descent
= 0;
9362 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
9363 MOVE_TO_POS
| MOVE_TO_VPOS
);
9365 while (!(IT_POS_VALID_AFTER_MOVE_P (&it2
)
9366 /* If we are in a display string which starts at START_POS,
9367 and that display string includes a newline, and we are
9368 right after that newline (i.e. at the beginning of a
9369 display line), exit the loop, because otherwise we will
9370 infloop, since move_it_to will see that it is already at
9371 START_POS and will not move. */
9372 || (it2
.method
== GET_FROM_STRING
9373 && IT_CHARPOS (it2
) == start_pos
9374 && SREF (it2
.string
, IT_STRING_BYTEPOS (it2
) - 1) == '\n')));
9375 eassert (IT_CHARPOS (*it
) >= BEGV
);
9376 SAVE_IT (it3
, it2
, it3data
);
9378 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
9379 eassert (IT_CHARPOS (*it
) >= BEGV
);
9380 /* H is the actual vertical distance from the position in *IT
9381 and the starting position. */
9382 h
= it2
.current_y
- it
->current_y
;
9383 /* NLINES is the distance in number of lines. */
9384 nlines
= it2
.vpos
- it
->vpos
;
9386 /* Correct IT's y and vpos position
9387 so that they are relative to the starting point. */
9393 /* DY == 0 means move to the start of the screen line. The
9394 value of nlines is > 0 if continuation lines were involved,
9395 or if the original IT position was at start of a line. */
9396 RESTORE_IT (it
, it
, it2data
);
9398 move_it_by_lines (it
, nlines
);
9399 /* The above code moves us to some position NLINES down,
9400 usually to its first glyph (leftmost in an L2R line), but
9401 that's not necessarily the start of the line, under bidi
9402 reordering. We want to get to the character position
9403 that is immediately after the newline of the previous
9406 && !it
->continuation_lines_width
9407 && !STRINGP (it
->string
)
9408 && IT_CHARPOS (*it
) > BEGV
9409 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9411 ptrdiff_t cp
= IT_CHARPOS (*it
), bp
= IT_BYTEPOS (*it
);
9414 cp
= find_newline_no_quit (cp
, bp
, -1, NULL
);
9415 move_it_to (it
, cp
, -1, -1, -1, MOVE_TO_POS
);
9417 bidi_unshelve_cache (it3data
, 1);
9421 /* The y-position we try to reach, relative to *IT.
9422 Note that H has been subtracted in front of the if-statement. */
9423 int target_y
= it
->current_y
+ h
- dy
;
9424 int y0
= it3
.current_y
;
9428 RESTORE_IT (&it3
, &it3
, it3data
);
9429 y1
= line_bottom_y (&it3
);
9430 line_height
= y1
- y0
;
9431 RESTORE_IT (it
, it
, it2data
);
9432 /* If we did not reach target_y, try to move further backward if
9433 we can. If we moved too far backward, try to move forward. */
9434 if (target_y
< it
->current_y
9435 /* This is heuristic. In a window that's 3 lines high, with
9436 a line height of 13 pixels each, recentering with point
9437 on the bottom line will try to move -39/2 = 19 pixels
9438 backward. Try to avoid moving into the first line. */
9439 && (it
->current_y
- target_y
9440 > min (window_box_height (it
->w
), line_height
* 2 / 3))
9441 && IT_CHARPOS (*it
) > BEGV
)
9443 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
9444 target_y
- it
->current_y
));
9445 dy
= it
->current_y
- target_y
;
9446 goto move_further_back
;
9448 else if (target_y
>= it
->current_y
+ line_height
9449 && IT_CHARPOS (*it
) < ZV
)
9451 /* Should move forward by at least one line, maybe more.
9453 Note: Calling move_it_by_lines can be expensive on
9454 terminal frames, where compute_motion is used (via
9455 vmotion) to do the job, when there are very long lines
9456 and truncate-lines is nil. That's the reason for
9457 treating terminal frames specially here. */
9459 if (!FRAME_WINDOW_P (it
->f
))
9460 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
9465 move_it_by_lines (it
, 1);
9467 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
9474 /* Move IT by a specified amount of pixel lines DY. DY negative means
9475 move backwards. DY = 0 means move to start of screen line. At the
9476 end, IT will be on the start of a screen line. */
9479 move_it_vertically (struct it
*it
, int dy
)
9482 move_it_vertically_backward (it
, -dy
);
9485 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
9486 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
9487 MOVE_TO_POS
| MOVE_TO_Y
);
9488 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
9490 /* If buffer ends in ZV without a newline, move to the start of
9491 the line to satisfy the post-condition. */
9492 if (IT_CHARPOS (*it
) == ZV
9494 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9495 move_it_by_lines (it
, 0);
9500 /* Move iterator IT past the end of the text line it is in. */
9503 move_it_past_eol (struct it
*it
)
9505 enum move_it_result rc
;
9507 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
9508 if (rc
== MOVE_NEWLINE_OR_CR
)
9509 set_iterator_to_next (it
, 0);
9513 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
9514 negative means move up. DVPOS == 0 means move to the start of the
9517 Optimization idea: If we would know that IT->f doesn't use
9518 a face with proportional font, we could be faster for
9519 truncate-lines nil. */
9522 move_it_by_lines (struct it
*it
, ptrdiff_t dvpos
)
9525 /* The commented-out optimization uses vmotion on terminals. This
9526 gives bad results, because elements like it->what, on which
9527 callers such as pos_visible_p rely, aren't updated. */
9528 /* struct position pos;
9529 if (!FRAME_WINDOW_P (it->f))
9531 struct text_pos textpos;
9533 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
9534 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
9535 reseat (it, textpos, 1);
9536 it->vpos += pos.vpos;
9537 it->current_y += pos.vpos;
9543 /* DVPOS == 0 means move to the start of the screen line. */
9544 move_it_vertically_backward (it
, 0);
9545 /* Let next call to line_bottom_y calculate real line height. */
9550 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
9551 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
9553 /* Only move to the next buffer position if we ended up in a
9554 string from display property, not in an overlay string
9555 (before-string or after-string). That is because the
9556 latter don't conceal the underlying buffer position, so
9557 we can ask to move the iterator to the exact position we
9558 are interested in. Note that, even if we are already at
9559 IT_CHARPOS (*it), the call below is not a no-op, as it
9560 will detect that we are at the end of the string, pop the
9561 iterator, and compute it->current_x and it->hpos
9563 move_it_to (it
, IT_CHARPOS (*it
) + it
->string_from_display_prop_p
,
9564 -1, -1, -1, MOVE_TO_POS
);
9570 void *it2data
= NULL
;
9571 ptrdiff_t start_charpos
, i
;
9573 = (it
->last_visible_x
- it
->first_visible_x
) / FRAME_COLUMN_WIDTH (it
->f
);
9574 bool hit_pos_limit
= false;
9575 ptrdiff_t pos_limit
;
9577 /* Start at the beginning of the screen line containing IT's
9578 position. This may actually move vertically backwards,
9579 in case of overlays, so adjust dvpos accordingly. */
9581 move_it_vertically_backward (it
, 0);
9584 /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
9585 screen lines, and reseat the iterator there. */
9586 start_charpos
= IT_CHARPOS (*it
);
9587 if (it
->line_wrap
== TRUNCATE
)
9590 pos_limit
= max (start_charpos
+ dvpos
* nchars_per_row
, BEGV
);
9592 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > pos_limit
; --i
)
9593 back_to_previous_visible_line_start (it
);
9594 if (i
> 0 && IT_CHARPOS (*it
) <= pos_limit
)
9595 hit_pos_limit
= true;
9596 reseat (it
, it
->current
.pos
, 1);
9598 /* Move further back if we end up in a string or an image. */
9599 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
9601 /* First try to move to start of display line. */
9603 move_it_vertically_backward (it
, 0);
9605 if (IT_POS_VALID_AFTER_MOVE_P (it
))
9607 /* If start of line is still in string or image,
9608 move further back. */
9609 back_to_previous_visible_line_start (it
);
9610 reseat (it
, it
->current
.pos
, 1);
9614 it
->current_x
= it
->hpos
= 0;
9616 /* Above call may have moved too far if continuation lines
9617 are involved. Scan forward and see if it did. */
9618 SAVE_IT (it2
, *it
, it2data
);
9619 it2
.vpos
= it2
.current_y
= 0;
9620 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
9621 it
->vpos
-= it2
.vpos
;
9622 it
->current_y
-= it2
.current_y
;
9623 it
->current_x
= it
->hpos
= 0;
9625 /* If we moved too far back, move IT some lines forward. */
9626 if (it2
.vpos
> -dvpos
)
9628 int delta
= it2
.vpos
+ dvpos
;
9630 RESTORE_IT (&it2
, &it2
, it2data
);
9631 SAVE_IT (it2
, *it
, it2data
);
9632 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
9633 /* Move back again if we got too far ahead. */
9634 if (IT_CHARPOS (*it
) >= start_charpos
)
9635 RESTORE_IT (it
, &it2
, it2data
);
9637 bidi_unshelve_cache (it2data
, 1);
9639 else if (hit_pos_limit
&& pos_limit
> BEGV
9640 && dvpos
< 0 && it2
.vpos
< -dvpos
)
9642 /* If we hit the limit, but still didn't make it far enough
9643 back, that means there's a display string with a newline
9644 covering a large chunk of text, and that caused
9645 back_to_previous_visible_line_start try to go too far.
9646 Punish those who commit such atrocities by going back
9647 until we've reached DVPOS, after lifting the limit, which
9648 could make it slow for very long lines. "If it hurts,
9651 RESTORE_IT (it
, it
, it2data
);
9652 for (i
= -dvpos
; i
> 0; --i
)
9654 back_to_previous_visible_line_start (it
);
9659 RESTORE_IT (it
, it
, it2data
);
9663 /* Return true if IT points into the middle of a display vector. */
9666 in_display_vector_p (struct it
*it
)
9668 return (it
->method
== GET_FROM_DISPLAY_VECTOR
9669 && it
->current
.dpvec_index
> 0
9670 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
9673 DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size
, Swindow_text_pixel_size
, 0, 6, 0,
9674 doc
: /* Return the size of the text of WINDOW's buffer in pixels.
9675 WINDOW must be a live window and defaults to the selected one. The
9676 return value is a cons of the maximum pixel-width of any text line and
9677 the maximum pixel-height of all text lines.
9679 The optional argument FROM, if non-nil, specifies the first text
9680 position and defaults to the minimum accessible position of the buffer.
9681 If FROM is t, use the minimum accessible position that is not a newline
9682 character. TO, if non-nil, specifies the last text position and
9683 defaults to the maximum accessible position of the buffer. If TO is t,
9684 use the maximum accessible position that is not a newline character.
9686 The optional argument X-LIMIT, if non-nil, specifies the maximum text
9687 width that can be returned. X-LIMIT nil or omitted, means to use the
9688 pixel-width of WINDOW's body; use this if you do not intend to change
9689 the width of WINDOW. Use the maximum width WINDOW may assume if you
9690 intend to change WINDOW's width. In any case, text whose x-coordinate
9691 is beyond X-LIMIT is ignored. Since calculating the width of long lines
9692 can take some time, it's always a good idea to make this argument as
9693 small as possible; in particular, if the buffer contains long lines that
9694 shall be truncated anyway.
9696 The optional argument Y-LIMIT, if non-nil, specifies the maximum text
9697 height that can be returned. Text lines whose y-coordinate is beyond
9698 Y-LIMIT are ignored. Since calculating the text height of a large
9699 buffer can take some time, it makes sense to specify this argument if
9700 the size of the buffer is unknown.
9702 Optional argument MODE-AND-HEADER-LINE nil or omitted means do not
9703 include the height of the mode- or header-line of WINDOW in the return
9704 value. If it is either the symbol `mode-line' or `header-line', include
9705 only the height of that line, if present, in the return value. If t,
9706 include the height of both, if present, in the return value. */)
9707 (Lisp_Object window
, Lisp_Object from
, Lisp_Object to
, Lisp_Object x_limit
, Lisp_Object y_limit
,
9708 Lisp_Object mode_and_header_line
)
9710 struct window
*w
= decode_live_window (window
);
9714 struct buffer
*old_buffer
= NULL
;
9715 ptrdiff_t start
, end
, pos
;
9716 struct text_pos startp
;
9717 void *itdata
= NULL
;
9718 int c
, max_y
= -1, x
= 0, y
= 0;
9724 if (b
!= current_buffer
)
9726 old_buffer
= current_buffer
;
9727 set_buffer_internal (b
);
9732 else if (EQ (from
, Qt
))
9735 while ((pos
++ < ZV
) && (c
= FETCH_CHAR (pos
))
9736 && (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\r'))
9738 while ((pos
-- > BEGV
) && (c
= FETCH_CHAR (pos
)) && (c
== ' ' || c
== '\t'))
9743 CHECK_NUMBER_COERCE_MARKER (from
);
9744 start
= min (max (XINT (from
), BEGV
), ZV
);
9749 else if (EQ (to
, Qt
))
9752 while ((pos
-- > BEGV
) && (c
= FETCH_CHAR (pos
))
9753 && (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\r'))
9755 while ((pos
++ < ZV
) && (c
= FETCH_CHAR (pos
)) && (c
== ' ' || c
== '\t'))
9760 CHECK_NUMBER_COERCE_MARKER (to
);
9761 end
= max (start
, min (XINT (to
), ZV
));
9764 if (!NILP (y_limit
))
9766 CHECK_NUMBER (y_limit
);
9767 max_y
= min (XINT (y_limit
), INT_MAX
);
9770 itdata
= bidi_shelve_cache ();
9771 SET_TEXT_POS (startp
, start
, CHAR_TO_BYTE (start
));
9772 start_display (&it
, w
, startp
);
9775 x
= move_it_to (&it
, end
, -1, max_y
, -1, MOVE_TO_POS
| MOVE_TO_Y
);
9778 CHECK_NUMBER (x_limit
);
9779 it
.last_visible_x
= min (XINT (x_limit
), INFINITY
);
9780 /* Actually, we never want move_it_to stop at to_x. But to make
9781 sure that move_it_in_display_line_to always moves far enough,
9782 we set it to INT_MAX and specify MOVE_TO_X. */
9783 x
= move_it_to (&it
, end
, INT_MAX
, max_y
, -1,
9784 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
9787 y
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
9789 if (!EQ (mode_and_header_line
, Qheader_line
)
9790 && !EQ (mode_and_header_line
, Qt
))
9791 /* Do not count the header-line which was counted automatically by
9793 y
= y
- WINDOW_HEADER_LINE_HEIGHT (w
);
9795 if (EQ (mode_and_header_line
, Qmode_line
)
9796 || EQ (mode_and_header_line
, Qt
))
9797 /* Do count the mode-line which is not included automatically by
9799 y
= y
+ WINDOW_MODE_LINE_HEIGHT (w
);
9801 bidi_unshelve_cache (itdata
, 0);
9804 set_buffer_internal (old_buffer
);
9806 return Fcons (make_number (x
), make_number (y
));
9809 /***********************************************************************
9811 ***********************************************************************/
9814 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
9818 add_to_log (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
9820 Lisp_Object args
[3];
9821 Lisp_Object msg
, fmt
;
9824 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9828 GCPRO4 (fmt
, msg
, arg1
, arg2
);
9830 args
[0] = fmt
= build_string (format
);
9833 msg
= Fformat (3, args
);
9835 len
= SBYTES (msg
) + 1;
9836 buffer
= SAFE_ALLOCA (len
);
9837 memcpy (buffer
, SDATA (msg
), len
);
9839 message_dolog (buffer
, len
- 1, 1, 0);
9846 /* Output a newline in the *Messages* buffer if "needs" one. */
9849 message_log_maybe_newline (void)
9851 if (message_log_need_newline
)
9852 message_dolog ("", 0, 1, 0);
9856 /* Add a string M of length NBYTES to the message log, optionally
9857 terminated with a newline when NLFLAG is true. MULTIBYTE, if
9858 true, means interpret the contents of M as multibyte. This
9859 function calls low-level routines in order to bypass text property
9860 hooks, etc. which might not be safe to run.
9862 This may GC (insert may run before/after change hooks),
9863 so the buffer M must NOT point to a Lisp string. */
9866 message_dolog (const char *m
, ptrdiff_t nbytes
, bool nlflag
, bool multibyte
)
9868 const unsigned char *msg
= (const unsigned char *) m
;
9870 if (!NILP (Vmemory_full
))
9873 if (!NILP (Vmessage_log_max
))
9875 struct buffer
*oldbuf
;
9876 Lisp_Object oldpoint
, oldbegv
, oldzv
;
9877 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
9878 ptrdiff_t point_at_end
= 0;
9879 ptrdiff_t zv_at_end
= 0;
9880 Lisp_Object old_deactivate_mark
;
9881 struct gcpro gcpro1
;
9883 old_deactivate_mark
= Vdeactivate_mark
;
9884 oldbuf
= current_buffer
;
9886 /* Ensure the Messages buffer exists, and switch to it.
9887 If we created it, set the major-mode. */
9890 if (NILP (Fget_buffer (Vmessages_buffer_name
))) newbuffer
= 1;
9892 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
9895 && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
9896 call0 (intern ("messages-buffer-mode"));
9899 bset_undo_list (current_buffer
, Qt
);
9900 bset_cache_long_scans (current_buffer
, Qnil
);
9902 oldpoint
= message_dolog_marker1
;
9903 set_marker_restricted_both (oldpoint
, Qnil
, PT
, PT_BYTE
);
9904 oldbegv
= message_dolog_marker2
;
9905 set_marker_restricted_both (oldbegv
, Qnil
, BEGV
, BEGV_BYTE
);
9906 oldzv
= message_dolog_marker3
;
9907 set_marker_restricted_both (oldzv
, Qnil
, ZV
, ZV_BYTE
);
9908 GCPRO1 (old_deactivate_mark
);
9916 BEGV_BYTE
= BEG_BYTE
;
9919 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
9921 /* Insert the string--maybe converting multibyte to single byte
9922 or vice versa, so that all the text fits the buffer. */
9924 && NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9930 /* Convert a multibyte string to single-byte
9931 for the *Message* buffer. */
9932 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
9934 c
= string_char_and_length (msg
+ i
, &char_bytes
);
9935 work
[0] = CHAR_TO_BYTE8 (c
);
9936 insert_1_both (work
, 1, 1, 1, 0, 0);
9939 else if (! multibyte
9940 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9944 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
9945 /* Convert a single-byte string to multibyte
9946 for the *Message* buffer. */
9947 for (i
= 0; i
< nbytes
; i
++)
9950 MAKE_CHAR_MULTIBYTE (c
);
9951 char_bytes
= CHAR_STRING (c
, str
);
9952 insert_1_both ((char *) str
, 1, char_bytes
, 1, 0, 0);
9956 insert_1_both (m
, chars_in_text (msg
, nbytes
), nbytes
, 1, 0, 0);
9960 ptrdiff_t this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
;
9963 insert_1_both ("\n", 1, 1, 1, 0, 0);
9965 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9967 this_bol_byte
= PT_BYTE
;
9969 /* See if this line duplicates the previous one.
9970 If so, combine duplicates. */
9973 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9975 prev_bol_byte
= PT_BYTE
;
9977 dups
= message_log_check_duplicate (prev_bol_byte
,
9981 del_range_both (prev_bol
, prev_bol_byte
,
9982 this_bol
, this_bol_byte
, 0);
9985 char dupstr
[sizeof " [ times]"
9986 + INT_STRLEN_BOUND (printmax_t
)];
9988 /* If you change this format, don't forget to also
9989 change message_log_check_duplicate. */
9990 int duplen
= sprintf (dupstr
, " [%"pMd
" times]", dups
);
9991 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
9992 insert_1_both (dupstr
, duplen
, duplen
, 1, 0, 1);
9997 /* If we have more than the desired maximum number of lines
9998 in the *Messages* buffer now, delete the oldest ones.
9999 This is safe because we don't have undo in this buffer. */
10001 if (NATNUMP (Vmessage_log_max
))
10003 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
10004 -XFASTINT (Vmessage_log_max
) - 1, 0);
10005 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
10008 BEGV
= marker_position (oldbegv
);
10009 BEGV_BYTE
= marker_byte_position (oldbegv
);
10018 ZV
= marker_position (oldzv
);
10019 ZV_BYTE
= marker_byte_position (oldzv
);
10023 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
10025 /* We can't do Fgoto_char (oldpoint) because it will run some
10027 TEMP_SET_PT_BOTH (marker_position (oldpoint
),
10028 marker_byte_position (oldpoint
));
10031 unchain_marker (XMARKER (oldpoint
));
10032 unchain_marker (XMARKER (oldbegv
));
10033 unchain_marker (XMARKER (oldzv
));
10035 /* We called insert_1_both above with its 5th argument (PREPARE)
10036 zero, which prevents insert_1_both from calling
10037 prepare_to_modify_buffer, which in turns prevents us from
10038 incrementing windows_or_buffers_changed even if *Messages* is
10039 shown in some window. So we must manually set
10040 windows_or_buffers_changed here to make up for that. */
10041 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10042 bset_redisplay (current_buffer
);
10044 set_buffer_internal (oldbuf
);
10046 message_log_need_newline
= !nlflag
;
10047 Vdeactivate_mark
= old_deactivate_mark
;
10052 /* We are at the end of the buffer after just having inserted a newline.
10053 (Note: We depend on the fact we won't be crossing the gap.)
10054 Check to see if the most recent message looks a lot like the previous one.
10055 Return 0 if different, 1 if the new one should just replace it, or a
10056 value N > 1 if we should also append " [N times]". */
10059 message_log_check_duplicate (ptrdiff_t prev_bol_byte
, ptrdiff_t this_bol_byte
)
10062 ptrdiff_t len
= Z_BYTE
- 1 - this_bol_byte
;
10064 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
10065 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
10067 for (i
= 0; i
< len
; i
++)
10069 if (i
>= 3 && p1
[i
- 3] == '.' && p1
[i
- 2] == '.' && p1
[i
- 1] == '.')
10071 if (p1
[i
] != p2
[i
])
10077 if (*p1
++ == ' ' && *p1
++ == '[')
10080 intmax_t n
= strtoimax ((char *) p1
, &pend
, 10);
10081 if (0 < n
&& n
< INTMAX_MAX
&& strncmp (pend
, " times]\n", 8) == 0)
10088 /* Display an echo area message M with a specified length of NBYTES
10089 bytes. The string may include null characters. If M is not a
10090 string, clear out any existing message, and let the mini-buffer
10093 This function cancels echoing. */
10096 message3 (Lisp_Object m
)
10098 struct gcpro gcpro1
;
10101 clear_message (true, true);
10104 /* First flush out any partial line written with print. */
10105 message_log_maybe_newline ();
10108 ptrdiff_t nbytes
= SBYTES (m
);
10109 bool multibyte
= STRING_MULTIBYTE (m
);
10111 char *buffer
= SAFE_ALLOCA (nbytes
);
10112 memcpy (buffer
, SDATA (m
), nbytes
);
10113 message_dolog (buffer
, nbytes
, 1, multibyte
);
10116 message3_nolog (m
);
10122 /* The non-logging version of message3.
10123 This does not cancel echoing, because it is used for echoing.
10124 Perhaps we need to make a separate function for echoing
10125 and make this cancel echoing. */
10128 message3_nolog (Lisp_Object m
)
10130 struct frame
*sf
= SELECTED_FRAME ();
10132 if (FRAME_INITIAL_P (sf
))
10134 if (noninteractive_need_newline
)
10135 putc ('\n', stderr
);
10136 noninteractive_need_newline
= 0;
10139 Lisp_Object s
= ENCODE_SYSTEM (m
);
10141 fwrite (SDATA (s
), SBYTES (s
), 1, stderr
);
10143 if (cursor_in_echo_area
== 0)
10144 fprintf (stderr
, "\n");
10147 /* Error messages get reported properly by cmd_error, so this must be just an
10148 informative message; if the frame hasn't really been initialized yet, just
10150 else if (INTERACTIVE
&& sf
->glyphs_initialized_p
)
10152 /* Get the frame containing the mini-buffer
10153 that the selected frame is using. */
10154 Lisp_Object mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10155 Lisp_Object frame
= XWINDOW (mini_window
)->frame
;
10156 struct frame
*f
= XFRAME (frame
);
10158 if (FRAME_VISIBLE_P (sf
) && !FRAME_VISIBLE_P (f
))
10159 Fmake_frame_visible (frame
);
10161 if (STRINGP (m
) && SCHARS (m
) > 0)
10164 if (minibuffer_auto_raise
)
10165 Fraise_frame (frame
);
10166 /* Assume we are not echoing.
10167 (If we are, echo_now will override this.) */
10168 echo_message_buffer
= Qnil
;
10171 clear_message (true, true);
10173 do_pending_window_change (0);
10174 echo_area_display (1);
10175 do_pending_window_change (0);
10176 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
10177 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
10182 /* Display a null-terminated echo area message M. If M is 0, clear
10183 out any existing message, and let the mini-buffer text show through.
10185 The buffer M must continue to exist until after the echo area gets
10186 cleared or some other message gets displayed there. Do not pass
10187 text that is stored in a Lisp string. Do not pass text in a buffer
10188 that was alloca'd. */
10191 message1 (const char *m
)
10193 message3 (m
? build_unibyte_string (m
) : Qnil
);
10197 /* The non-logging counterpart of message1. */
10200 message1_nolog (const char *m
)
10202 message3_nolog (m
? build_unibyte_string (m
) : Qnil
);
10205 /* Display a message M which contains a single %s
10206 which gets replaced with STRING. */
10209 message_with_string (const char *m
, Lisp_Object string
, int log
)
10211 CHECK_STRING (string
);
10213 if (noninteractive
)
10217 /* ENCODE_SYSTEM below can GC and/or relocate the
10218 Lisp data, so make sure we don't use it here. */
10219 eassert (relocatable_string_data_p (m
) != 1);
10221 if (noninteractive_need_newline
)
10222 putc ('\n', stderr
);
10223 noninteractive_need_newline
= 0;
10224 fprintf (stderr
, m
, SDATA (ENCODE_SYSTEM (string
)));
10225 if (!cursor_in_echo_area
)
10226 fprintf (stderr
, "\n");
10230 else if (INTERACTIVE
)
10232 /* The frame whose minibuffer we're going to display the message on.
10233 It may be larger than the selected frame, so we need
10234 to use its buffer, not the selected frame's buffer. */
10235 Lisp_Object mini_window
;
10236 struct frame
*f
, *sf
= SELECTED_FRAME ();
10238 /* Get the frame containing the minibuffer
10239 that the selected frame is using. */
10240 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10241 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
10243 /* Error messages get reported properly by cmd_error, so this must be
10244 just an informative message; if the frame hasn't really been
10245 initialized yet, just toss it. */
10246 if (f
->glyphs_initialized_p
)
10248 Lisp_Object args
[2], msg
;
10249 struct gcpro gcpro1
, gcpro2
;
10251 args
[0] = build_string (m
);
10252 args
[1] = msg
= string
;
10253 GCPRO2 (args
[0], msg
);
10256 msg
= Fformat (2, args
);
10261 message3_nolog (msg
);
10265 /* Print should start at the beginning of the message
10266 buffer next time. */
10267 message_buf_print
= 0;
10273 /* Dump an informative message to the minibuf. If M is 0, clear out
10274 any existing message, and let the mini-buffer text show through. */
10277 vmessage (const char *m
, va_list ap
)
10279 if (noninteractive
)
10283 if (noninteractive_need_newline
)
10284 putc ('\n', stderr
);
10285 noninteractive_need_newline
= 0;
10286 vfprintf (stderr
, m
, ap
);
10287 if (cursor_in_echo_area
== 0)
10288 fprintf (stderr
, "\n");
10292 else if (INTERACTIVE
)
10294 /* The frame whose mini-buffer we're going to display the message
10295 on. It may be larger than the selected frame, so we need to
10296 use its buffer, not the selected frame's buffer. */
10297 Lisp_Object mini_window
;
10298 struct frame
*f
, *sf
= SELECTED_FRAME ();
10300 /* Get the frame containing the mini-buffer
10301 that the selected frame is using. */
10302 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10303 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
10305 /* Error messages get reported properly by cmd_error, so this must be
10306 just an informative message; if the frame hasn't really been
10307 initialized yet, just toss it. */
10308 if (f
->glyphs_initialized_p
)
10313 ptrdiff_t maxsize
= FRAME_MESSAGE_BUF_SIZE (f
);
10314 char *message_buf
= alloca (maxsize
+ 1);
10316 len
= doprnt (message_buf
, maxsize
, m
, 0, ap
);
10318 message3 (make_string (message_buf
, len
));
10323 /* Print should start at the beginning of the message
10324 buffer next time. */
10325 message_buf_print
= 0;
10331 message (const char *m
, ...)
10341 /* The non-logging version of message. */
10344 message_nolog (const char *m
, ...)
10346 Lisp_Object old_log_max
;
10349 old_log_max
= Vmessage_log_max
;
10350 Vmessage_log_max
= Qnil
;
10352 Vmessage_log_max
= old_log_max
;
10358 /* Display the current message in the current mini-buffer. This is
10359 only called from error handlers in process.c, and is not time
10363 update_echo_area (void)
10365 if (!NILP (echo_area_buffer
[0]))
10367 Lisp_Object string
;
10368 string
= Fcurrent_message ();
10374 /* Make sure echo area buffers in `echo_buffers' are live.
10375 If they aren't, make new ones. */
10378 ensure_echo_area_buffers (void)
10382 for (i
= 0; i
< 2; ++i
)
10383 if (!BUFFERP (echo_buffer
[i
])
10384 || !BUFFER_LIVE_P (XBUFFER (echo_buffer
[i
])))
10387 Lisp_Object old_buffer
;
10390 old_buffer
= echo_buffer
[i
];
10391 echo_buffer
[i
] = Fget_buffer_create
10392 (make_formatted_string (name
, " *Echo Area %d*", i
));
10393 bset_truncate_lines (XBUFFER (echo_buffer
[i
]), Qnil
);
10394 /* to force word wrap in echo area -
10395 it was decided to postpone this*/
10396 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
10398 for (j
= 0; j
< 2; ++j
)
10399 if (EQ (old_buffer
, echo_area_buffer
[j
]))
10400 echo_area_buffer
[j
] = echo_buffer
[i
];
10405 /* Call FN with args A1..A2 with either the current or last displayed
10406 echo_area_buffer as current buffer.
10408 WHICH zero means use the current message buffer
10409 echo_area_buffer[0]. If that is nil, choose a suitable buffer
10410 from echo_buffer[] and clear it.
10412 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
10413 suitable buffer from echo_buffer[] and clear it.
10415 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
10416 that the current message becomes the last displayed one, make
10417 choose a suitable buffer for echo_area_buffer[0], and clear it.
10419 Value is what FN returns. */
10422 with_echo_area_buffer (struct window
*w
, int which
,
10423 int (*fn
) (ptrdiff_t, Lisp_Object
),
10424 ptrdiff_t a1
, Lisp_Object a2
)
10426 Lisp_Object buffer
;
10427 int this_one
, the_other
, clear_buffer_p
, rc
;
10428 ptrdiff_t count
= SPECPDL_INDEX ();
10430 /* If buffers aren't live, make new ones. */
10431 ensure_echo_area_buffers ();
10433 clear_buffer_p
= 0;
10436 this_one
= 0, the_other
= 1;
10437 else if (which
> 0)
10438 this_one
= 1, the_other
= 0;
10441 this_one
= 0, the_other
= 1;
10442 clear_buffer_p
= true;
10444 /* We need a fresh one in case the current echo buffer equals
10445 the one containing the last displayed echo area message. */
10446 if (!NILP (echo_area_buffer
[this_one
])
10447 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
10448 echo_area_buffer
[this_one
] = Qnil
;
10451 /* Choose a suitable buffer from echo_buffer[] is we don't
10453 if (NILP (echo_area_buffer
[this_one
]))
10455 echo_area_buffer
[this_one
]
10456 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
10457 ? echo_buffer
[the_other
]
10458 : echo_buffer
[this_one
]);
10459 clear_buffer_p
= true;
10462 buffer
= echo_area_buffer
[this_one
];
10464 /* Don't get confused by reusing the buffer used for echoing
10465 for a different purpose. */
10466 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
10469 record_unwind_protect (unwind_with_echo_area_buffer
,
10470 with_echo_area_buffer_unwind_data (w
));
10472 /* Make the echo area buffer current. Note that for display
10473 purposes, it is not necessary that the displayed window's buffer
10474 == current_buffer, except for text property lookup. So, let's
10475 only set that buffer temporarily here without doing a full
10476 Fset_window_buffer. We must also change w->pointm, though,
10477 because otherwise an assertions in unshow_buffer fails, and Emacs
10479 set_buffer_internal_1 (XBUFFER (buffer
));
10482 wset_buffer (w
, buffer
);
10483 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
10486 bset_undo_list (current_buffer
, Qt
);
10487 bset_read_only (current_buffer
, Qnil
);
10488 specbind (Qinhibit_read_only
, Qt
);
10489 specbind (Qinhibit_modification_hooks
, Qt
);
10491 if (clear_buffer_p
&& Z
> BEG
)
10492 del_range (BEG
, Z
);
10494 eassert (BEGV
>= BEG
);
10495 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10499 eassert (BEGV
>= BEG
);
10500 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10502 unbind_to (count
, Qnil
);
10507 /* Save state that should be preserved around the call to the function
10508 FN called in with_echo_area_buffer. */
10511 with_echo_area_buffer_unwind_data (struct window
*w
)
10514 Lisp_Object vector
, tmp
;
10516 /* Reduce consing by keeping one vector in
10517 Vwith_echo_area_save_vector. */
10518 vector
= Vwith_echo_area_save_vector
;
10519 Vwith_echo_area_save_vector
= Qnil
;
10522 vector
= Fmake_vector (make_number (9), Qnil
);
10524 XSETBUFFER (tmp
, current_buffer
); ASET (vector
, i
, tmp
); ++i
;
10525 ASET (vector
, i
, Vdeactivate_mark
); ++i
;
10526 ASET (vector
, i
, make_number (windows_or_buffers_changed
)); ++i
;
10530 XSETWINDOW (tmp
, w
); ASET (vector
, i
, tmp
); ++i
;
10531 ASET (vector
, i
, w
->contents
); ++i
;
10532 ASET (vector
, i
, make_number (marker_position (w
->pointm
))); ++i
;
10533 ASET (vector
, i
, make_number (marker_byte_position (w
->pointm
))); ++i
;
10534 ASET (vector
, i
, make_number (marker_position (w
->start
))); ++i
;
10535 ASET (vector
, i
, make_number (marker_byte_position (w
->start
))); ++i
;
10540 for (; i
< end
; ++i
)
10541 ASET (vector
, i
, Qnil
);
10544 eassert (i
== ASIZE (vector
));
10549 /* Restore global state from VECTOR which was created by
10550 with_echo_area_buffer_unwind_data. */
10553 unwind_with_echo_area_buffer (Lisp_Object vector
)
10555 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
10556 Vdeactivate_mark
= AREF (vector
, 1);
10557 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
10559 if (WINDOWP (AREF (vector
, 3)))
10562 Lisp_Object buffer
;
10564 w
= XWINDOW (AREF (vector
, 3));
10565 buffer
= AREF (vector
, 4);
10567 wset_buffer (w
, buffer
);
10568 set_marker_both (w
->pointm
, buffer
,
10569 XFASTINT (AREF (vector
, 5)),
10570 XFASTINT (AREF (vector
, 6)));
10571 set_marker_both (w
->start
, buffer
,
10572 XFASTINT (AREF (vector
, 7)),
10573 XFASTINT (AREF (vector
, 8)));
10576 Vwith_echo_area_save_vector
= vector
;
10580 /* Set up the echo area for use by print functions. MULTIBYTE_P
10581 non-zero means we will print multibyte. */
10584 setup_echo_area_for_printing (int multibyte_p
)
10586 /* If we can't find an echo area any more, exit. */
10587 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
10588 Fkill_emacs (Qnil
);
10590 ensure_echo_area_buffers ();
10592 if (!message_buf_print
)
10594 /* A message has been output since the last time we printed.
10595 Choose a fresh echo area buffer. */
10596 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10597 echo_area_buffer
[0] = echo_buffer
[1];
10599 echo_area_buffer
[0] = echo_buffer
[0];
10601 /* Switch to that buffer and clear it. */
10602 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10603 bset_truncate_lines (current_buffer
, Qnil
);
10607 ptrdiff_t count
= SPECPDL_INDEX ();
10608 specbind (Qinhibit_read_only
, Qt
);
10609 /* Note that undo recording is always disabled. */
10610 del_range (BEG
, Z
);
10611 unbind_to (count
, Qnil
);
10613 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10615 /* Set up the buffer for the multibyteness we need. */
10617 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10618 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
10620 /* Raise the frame containing the echo area. */
10621 if (minibuffer_auto_raise
)
10623 struct frame
*sf
= SELECTED_FRAME ();
10624 Lisp_Object mini_window
;
10625 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10626 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
10629 message_log_maybe_newline ();
10630 message_buf_print
= 1;
10634 if (NILP (echo_area_buffer
[0]))
10636 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10637 echo_area_buffer
[0] = echo_buffer
[1];
10639 echo_area_buffer
[0] = echo_buffer
[0];
10642 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
10644 /* Someone switched buffers between print requests. */
10645 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10646 bset_truncate_lines (current_buffer
, Qnil
);
10652 /* Display an echo area message in window W. Value is non-zero if W's
10653 height is changed. If display_last_displayed_message_p is
10654 non-zero, display the message that was last displayed, otherwise
10655 display the current message. */
10658 display_echo_area (struct window
*w
)
10660 int i
, no_message_p
, window_height_changed_p
;
10662 /* Temporarily disable garbage collections while displaying the echo
10663 area. This is done because a GC can print a message itself.
10664 That message would modify the echo area buffer's contents while a
10665 redisplay of the buffer is going on, and seriously confuse
10667 ptrdiff_t count
= inhibit_garbage_collection ();
10669 /* If there is no message, we must call display_echo_area_1
10670 nevertheless because it resizes the window. But we will have to
10671 reset the echo_area_buffer in question to nil at the end because
10672 with_echo_area_buffer will sets it to an empty buffer. */
10673 i
= display_last_displayed_message_p
? 1 : 0;
10674 no_message_p
= NILP (echo_area_buffer
[i
]);
10676 window_height_changed_p
10677 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
10678 display_echo_area_1
,
10679 (intptr_t) w
, Qnil
);
10682 echo_area_buffer
[i
] = Qnil
;
10684 unbind_to (count
, Qnil
);
10685 return window_height_changed_p
;
10689 /* Helper for display_echo_area. Display the current buffer which
10690 contains the current echo area message in window W, a mini-window,
10691 a pointer to which is passed in A1. A2..A4 are currently not used.
10692 Change the height of W so that all of the message is displayed.
10693 Value is non-zero if height of W was changed. */
10696 display_echo_area_1 (ptrdiff_t a1
, Lisp_Object a2
)
10699 struct window
*w
= (struct window
*) i1
;
10700 Lisp_Object window
;
10701 struct text_pos start
;
10702 int window_height_changed_p
= 0;
10704 /* Do this before displaying, so that we have a large enough glyph
10705 matrix for the display. If we can't get enough space for the
10706 whole text, display the last N lines. That works by setting w->start. */
10707 window_height_changed_p
= resize_mini_window (w
, 0);
10709 /* Use the starting position chosen by resize_mini_window. */
10710 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
10713 clear_glyph_matrix (w
->desired_matrix
);
10714 XSETWINDOW (window
, w
);
10715 try_window (window
, start
, 0);
10717 return window_height_changed_p
;
10721 /* Resize the echo area window to exactly the size needed for the
10722 currently displayed message, if there is one. If a mini-buffer
10723 is active, don't shrink it. */
10726 resize_echo_area_exactly (void)
10728 if (BUFFERP (echo_area_buffer
[0])
10729 && WINDOWP (echo_area_window
))
10731 struct window
*w
= XWINDOW (echo_area_window
);
10732 Lisp_Object resize_exactly
= (minibuf_level
== 0 ? Qt
: Qnil
);
10733 int resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
10734 (intptr_t) w
, resize_exactly
);
10737 windows_or_buffers_changed
= 42;
10738 update_mode_lines
= 30;
10739 redisplay_internal ();
10745 /* Callback function for with_echo_area_buffer, when used from
10746 resize_echo_area_exactly. A1 contains a pointer to the window to
10747 resize, EXACTLY non-nil means resize the mini-window exactly to the
10748 size of the text displayed. A3 and A4 are not used. Value is what
10749 resize_mini_window returns. */
10752 resize_mini_window_1 (ptrdiff_t a1
, Lisp_Object exactly
)
10755 return resize_mini_window ((struct window
*) i1
, !NILP (exactly
));
10759 /* Resize mini-window W to fit the size of its contents. EXACT_P
10760 means size the window exactly to the size needed. Otherwise, it's
10761 only enlarged until W's buffer is empty.
10763 Set W->start to the right place to begin display. If the whole
10764 contents fit, start at the beginning. Otherwise, start so as
10765 to make the end of the contents appear. This is particularly
10766 important for y-or-n-p, but seems desirable generally.
10768 Value is non-zero if the window height has been changed. */
10771 resize_mini_window (struct window
*w
, int exact_p
)
10773 struct frame
*f
= XFRAME (w
->frame
);
10774 int window_height_changed_p
= 0;
10776 eassert (MINI_WINDOW_P (w
));
10778 /* By default, start display at the beginning. */
10779 set_marker_both (w
->start
, w
->contents
,
10780 BUF_BEGV (XBUFFER (w
->contents
)),
10781 BUF_BEGV_BYTE (XBUFFER (w
->contents
)));
10783 /* Don't resize windows while redisplaying a window; it would
10784 confuse redisplay functions when the size of the window they are
10785 displaying changes from under them. Such a resizing can happen,
10786 for instance, when which-func prints a long message while
10787 we are running fontification-functions. We're running these
10788 functions with safe_call which binds inhibit-redisplay to t. */
10789 if (!NILP (Vinhibit_redisplay
))
10792 /* Nil means don't try to resize. */
10793 if (NILP (Vresize_mini_windows
)
10794 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
10797 if (!FRAME_MINIBUF_ONLY_P (f
))
10800 int total_height
= (WINDOW_PIXEL_HEIGHT (XWINDOW (FRAME_ROOT_WINDOW (f
)))
10801 + WINDOW_PIXEL_HEIGHT (w
));
10802 int unit
= FRAME_LINE_HEIGHT (f
);
10803 int height
, max_height
;
10804 struct text_pos start
;
10805 struct buffer
*old_current_buffer
= NULL
;
10807 if (current_buffer
!= XBUFFER (w
->contents
))
10809 old_current_buffer
= current_buffer
;
10810 set_buffer_internal (XBUFFER (w
->contents
));
10813 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10815 /* Compute the max. number of lines specified by the user. */
10816 if (FLOATP (Vmax_mini_window_height
))
10817 max_height
= XFLOATINT (Vmax_mini_window_height
) * total_height
;
10818 else if (INTEGERP (Vmax_mini_window_height
))
10819 max_height
= XINT (Vmax_mini_window_height
) * unit
;
10821 max_height
= total_height
/ 4;
10823 /* Correct that max. height if it's bogus. */
10824 max_height
= clip_to_bounds (unit
, max_height
, total_height
);
10826 /* Find out the height of the text in the window. */
10827 if (it
.line_wrap
== TRUNCATE
)
10832 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
10833 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
10834 height
= it
.current_y
+ last_height
;
10836 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
10837 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
10840 /* Compute a suitable window start. */
10841 if (height
> max_height
)
10843 height
= (max_height
/ unit
) * unit
;
10844 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10845 move_it_vertically_backward (&it
, height
- unit
);
10846 start
= it
.current
.pos
;
10849 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
10850 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
10852 if (EQ (Vresize_mini_windows
, Qgrow_only
))
10854 /* Let it grow only, until we display an empty message, in which
10855 case the window shrinks again. */
10856 if (height
> WINDOW_PIXEL_HEIGHT (w
))
10858 int old_height
= WINDOW_PIXEL_HEIGHT (w
);
10860 FRAME_WINDOWS_FROZEN (f
) = 1;
10861 grow_mini_window (w
, height
- WINDOW_PIXEL_HEIGHT (w
), 1);
10862 window_height_changed_p
= WINDOW_PIXEL_HEIGHT (w
) != old_height
;
10864 else if (height
< WINDOW_PIXEL_HEIGHT (w
)
10865 && (exact_p
|| BEGV
== ZV
))
10867 int old_height
= WINDOW_PIXEL_HEIGHT (w
);
10869 FRAME_WINDOWS_FROZEN (f
) = 0;
10870 shrink_mini_window (w
, 1);
10871 window_height_changed_p
= WINDOW_PIXEL_HEIGHT (w
) != old_height
;
10876 /* Always resize to exact size needed. */
10877 if (height
> WINDOW_PIXEL_HEIGHT (w
))
10879 int old_height
= WINDOW_PIXEL_HEIGHT (w
);
10881 FRAME_WINDOWS_FROZEN (f
) = 1;
10882 grow_mini_window (w
, height
- WINDOW_PIXEL_HEIGHT (w
), 1);
10883 window_height_changed_p
= WINDOW_PIXEL_HEIGHT (w
) != old_height
;
10885 else if (height
< WINDOW_PIXEL_HEIGHT (w
))
10887 int old_height
= WINDOW_PIXEL_HEIGHT (w
);
10889 FRAME_WINDOWS_FROZEN (f
) = 0;
10890 shrink_mini_window (w
, 1);
10894 FRAME_WINDOWS_FROZEN (f
) = 1;
10895 grow_mini_window (w
, height
- WINDOW_PIXEL_HEIGHT (w
), 1);
10898 window_height_changed_p
= WINDOW_PIXEL_HEIGHT (w
) != old_height
;
10902 if (old_current_buffer
)
10903 set_buffer_internal (old_current_buffer
);
10906 return window_height_changed_p
;
10910 /* Value is the current message, a string, or nil if there is no
10911 current message. */
10914 current_message (void)
10918 if (!BUFFERP (echo_area_buffer
[0]))
10922 with_echo_area_buffer (0, 0, current_message_1
,
10923 (intptr_t) &msg
, Qnil
);
10925 echo_area_buffer
[0] = Qnil
;
10933 current_message_1 (ptrdiff_t a1
, Lisp_Object a2
)
10936 Lisp_Object
*msg
= (Lisp_Object
*) i1
;
10939 *msg
= make_buffer_string (BEG
, Z
, 1);
10946 /* Push the current message on Vmessage_stack for later restoration
10947 by restore_message. Value is non-zero if the current message isn't
10948 empty. This is a relatively infrequent operation, so it's not
10949 worth optimizing. */
10952 push_message (void)
10954 Lisp_Object msg
= current_message ();
10955 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
10956 return STRINGP (msg
);
10960 /* Restore message display from the top of Vmessage_stack. */
10963 restore_message (void)
10965 eassert (CONSP (Vmessage_stack
));
10966 message3_nolog (XCAR (Vmessage_stack
));
10970 /* Handler for unwind-protect calling pop_message. */
10973 pop_message_unwind (void)
10975 /* Pop the top-most entry off Vmessage_stack. */
10976 eassert (CONSP (Vmessage_stack
));
10977 Vmessage_stack
= XCDR (Vmessage_stack
);
10981 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
10982 exits. If the stack is not empty, we have a missing pop_message
10986 check_message_stack (void)
10988 if (!NILP (Vmessage_stack
))
10993 /* Truncate to NCHARS what will be displayed in the echo area the next
10994 time we display it---but don't redisplay it now. */
10997 truncate_echo_area (ptrdiff_t nchars
)
11000 echo_area_buffer
[0] = Qnil
;
11001 else if (!noninteractive
11003 && !NILP (echo_area_buffer
[0]))
11005 struct frame
*sf
= SELECTED_FRAME ();
11006 /* Error messages get reported properly by cmd_error, so this must be
11007 just an informative message; if the frame hasn't really been
11008 initialized yet, just toss it. */
11009 if (sf
->glyphs_initialized_p
)
11010 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
);
11015 /* Helper function for truncate_echo_area. Truncate the current
11016 message to at most NCHARS characters. */
11019 truncate_message_1 (ptrdiff_t nchars
, Lisp_Object a2
)
11021 if (BEG
+ nchars
< Z
)
11022 del_range (BEG
+ nchars
, Z
);
11024 echo_area_buffer
[0] = Qnil
;
11028 /* Set the current message to STRING. */
11031 set_message (Lisp_Object string
)
11033 eassert (STRINGP (string
));
11035 message_enable_multibyte
= STRING_MULTIBYTE (string
);
11037 with_echo_area_buffer (0, -1, set_message_1
, 0, string
);
11038 message_buf_print
= 0;
11039 help_echo_showing_p
= 0;
11041 if (STRINGP (Vdebug_on_message
)
11042 && STRINGP (string
)
11043 && fast_string_match (Vdebug_on_message
, string
) >= 0)
11044 call_debugger (list2 (Qerror
, string
));
11048 /* Helper function for set_message. First argument is ignored and second
11049 argument has the same meaning as for set_message.
11050 This function is called with the echo area buffer being current. */
11053 set_message_1 (ptrdiff_t a1
, Lisp_Object string
)
11055 eassert (STRINGP (string
));
11057 /* Change multibyteness of the echo buffer appropriately. */
11058 if (message_enable_multibyte
11059 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
11060 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
11062 bset_truncate_lines (current_buffer
, message_truncate_lines
? Qt
: Qnil
);
11063 if (!NILP (BVAR (current_buffer
, bidi_display_reordering
)))
11064 bset_bidi_paragraph_direction (current_buffer
, Qleft_to_right
);
11066 /* Insert new message at BEG. */
11067 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
11069 /* This function takes care of single/multibyte conversion.
11070 We just have to ensure that the echo area buffer has the right
11071 setting of enable_multibyte_characters. */
11072 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 1);
11078 /* Clear messages. CURRENT_P non-zero means clear the current
11079 message. LAST_DISPLAYED_P non-zero means clear the message
11083 clear_message (bool current_p
, bool last_displayed_p
)
11087 echo_area_buffer
[0] = Qnil
;
11088 message_cleared_p
= true;
11091 if (last_displayed_p
)
11092 echo_area_buffer
[1] = Qnil
;
11094 message_buf_print
= 0;
11097 /* Clear garbaged frames.
11099 This function is used where the old redisplay called
11100 redraw_garbaged_frames which in turn called redraw_frame which in
11101 turn called clear_frame. The call to clear_frame was a source of
11102 flickering. I believe a clear_frame is not necessary. It should
11103 suffice in the new redisplay to invalidate all current matrices,
11104 and ensure a complete redisplay of all windows. */
11107 clear_garbaged_frames (void)
11109 if (frame_garbaged
)
11111 Lisp_Object tail
, frame
;
11113 FOR_EACH_FRAME (tail
, frame
)
11115 struct frame
*f
= XFRAME (frame
);
11117 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
11122 clear_current_matrices (f
);
11123 fset_redisplay (f
);
11124 f
->garbaged
= false;
11125 f
->resized_p
= false;
11129 frame_garbaged
= false;
11134 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
11135 is non-zero update selected_frame. Value is non-zero if the
11136 mini-windows height has been changed. */
11139 echo_area_display (int update_frame_p
)
11141 Lisp_Object mini_window
;
11144 int window_height_changed_p
= 0;
11145 struct frame
*sf
= SELECTED_FRAME ();
11147 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
11148 w
= XWINDOW (mini_window
);
11149 f
= XFRAME (WINDOW_FRAME (w
));
11151 /* Don't display if frame is invisible or not yet initialized. */
11152 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
11155 #ifdef HAVE_WINDOW_SYSTEM
11156 /* When Emacs starts, selected_frame may be the initial terminal
11157 frame. If we let this through, a message would be displayed on
11159 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
11161 #endif /* HAVE_WINDOW_SYSTEM */
11163 /* Redraw garbaged frames. */
11164 clear_garbaged_frames ();
11166 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
11168 echo_area_window
= mini_window
;
11169 window_height_changed_p
= display_echo_area (w
);
11170 w
->must_be_updated_p
= true;
11172 /* Update the display, unless called from redisplay_internal.
11173 Also don't update the screen during redisplay itself. The
11174 update will happen at the end of redisplay, and an update
11175 here could cause confusion. */
11176 if (update_frame_p
&& !redisplaying_p
)
11180 /* If the display update has been interrupted by pending
11181 input, update mode lines in the frame. Due to the
11182 pending input, it might have been that redisplay hasn't
11183 been called, so that mode lines above the echo area are
11184 garbaged. This looks odd, so we prevent it here. */
11185 if (!display_completed
)
11186 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), false);
11188 if (window_height_changed_p
11189 /* Don't do this if Emacs is shutting down. Redisplay
11190 needs to run hooks. */
11191 && !NILP (Vrun_hooks
))
11193 /* Must update other windows. Likewise as in other
11194 cases, don't let this update be interrupted by
11196 ptrdiff_t count
= SPECPDL_INDEX ();
11197 specbind (Qredisplay_dont_pause
, Qt
);
11198 windows_or_buffers_changed
= 44;
11199 redisplay_internal ();
11200 unbind_to (count
, Qnil
);
11202 else if (FRAME_WINDOW_P (f
) && n
== 0)
11204 /* Window configuration is the same as before.
11205 Can do with a display update of the echo area,
11206 unless we displayed some mode lines. */
11207 update_single_window (w
, 1);
11211 update_frame (f
, 1, 1);
11213 /* If cursor is in the echo area, make sure that the next
11214 redisplay displays the minibuffer, so that the cursor will
11215 be replaced with what the minibuffer wants. */
11216 if (cursor_in_echo_area
)
11217 wset_redisplay (XWINDOW (mini_window
));
11220 else if (!EQ (mini_window
, selected_window
))
11221 wset_redisplay (XWINDOW (mini_window
));
11223 /* Last displayed message is now the current message. */
11224 echo_area_buffer
[1] = echo_area_buffer
[0];
11225 /* Inform read_char that we're not echoing. */
11226 echo_message_buffer
= Qnil
;
11228 /* Prevent redisplay optimization in redisplay_internal by resetting
11229 this_line_start_pos. This is done because the mini-buffer now
11230 displays the message instead of its buffer text. */
11231 if (EQ (mini_window
, selected_window
))
11232 CHARPOS (this_line_start_pos
) = 0;
11234 return window_height_changed_p
;
11237 /* Nonzero if W's buffer was changed but not saved. */
11240 window_buffer_changed (struct window
*w
)
11242 struct buffer
*b
= XBUFFER (w
->contents
);
11244 eassert (BUFFER_LIVE_P (b
));
11246 return (((BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)) != w
->last_had_star
));
11249 /* Nonzero if W has %c in its mode line and mode line should be updated. */
11252 mode_line_update_needed (struct window
*w
)
11254 return (w
->column_number_displayed
!= -1
11255 && !(PT
== w
->last_point
&& !window_outdated (w
))
11256 && (w
->column_number_displayed
!= current_column ()));
11259 /* Nonzero if window start of W is frozen and may not be changed during
11263 window_frozen_p (struct window
*w
)
11265 if (FRAME_WINDOWS_FROZEN (XFRAME (WINDOW_FRAME (w
))))
11267 Lisp_Object window
;
11269 XSETWINDOW (window
, w
);
11270 if (MINI_WINDOW_P (w
))
11272 else if (EQ (window
, selected_window
))
11274 else if (MINI_WINDOW_P (XWINDOW (selected_window
))
11275 && EQ (window
, Vminibuf_scroll_window
))
11276 /* This special window can't be frozen too. */
11284 /***********************************************************************
11285 Mode Lines and Frame Titles
11286 ***********************************************************************/
11288 /* A buffer for constructing non-propertized mode-line strings and
11289 frame titles in it; allocated from the heap in init_xdisp and
11290 resized as needed in store_mode_line_noprop_char. */
11292 static char *mode_line_noprop_buf
;
11294 /* The buffer's end, and a current output position in it. */
11296 static char *mode_line_noprop_buf_end
;
11297 static char *mode_line_noprop_ptr
;
11299 #define MODE_LINE_NOPROP_LEN(start) \
11300 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
11303 MODE_LINE_DISPLAY
= 0,
11307 } mode_line_target
;
11309 /* Alist that caches the results of :propertize.
11310 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
11311 static Lisp_Object mode_line_proptrans_alist
;
11313 /* List of strings making up the mode-line. */
11314 static Lisp_Object mode_line_string_list
;
11316 /* Base face property when building propertized mode line string. */
11317 static Lisp_Object mode_line_string_face
;
11318 static Lisp_Object mode_line_string_face_prop
;
11321 /* Unwind data for mode line strings */
11323 static Lisp_Object Vmode_line_unwind_vector
;
11326 format_mode_line_unwind_data (struct frame
*target_frame
,
11327 struct buffer
*obuf
,
11329 int save_proptrans
)
11331 Lisp_Object vector
, tmp
;
11333 /* Reduce consing by keeping one vector in
11334 Vwith_echo_area_save_vector. */
11335 vector
= Vmode_line_unwind_vector
;
11336 Vmode_line_unwind_vector
= Qnil
;
11339 vector
= Fmake_vector (make_number (10), Qnil
);
11341 ASET (vector
, 0, make_number (mode_line_target
));
11342 ASET (vector
, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
11343 ASET (vector
, 2, mode_line_string_list
);
11344 ASET (vector
, 3, save_proptrans
? mode_line_proptrans_alist
: Qt
);
11345 ASET (vector
, 4, mode_line_string_face
);
11346 ASET (vector
, 5, mode_line_string_face_prop
);
11349 XSETBUFFER (tmp
, obuf
);
11352 ASET (vector
, 6, tmp
);
11353 ASET (vector
, 7, owin
);
11356 /* Similarly to `with-selected-window', if the operation selects
11357 a window on another frame, we must restore that frame's
11358 selected window, and (for a tty) the top-frame. */
11359 ASET (vector
, 8, target_frame
->selected_window
);
11360 if (FRAME_TERMCAP_P (target_frame
))
11361 ASET (vector
, 9, FRAME_TTY (target_frame
)->top_frame
);
11368 unwind_format_mode_line (Lisp_Object vector
)
11370 Lisp_Object old_window
= AREF (vector
, 7);
11371 Lisp_Object target_frame_window
= AREF (vector
, 8);
11372 Lisp_Object old_top_frame
= AREF (vector
, 9);
11374 mode_line_target
= XINT (AREF (vector
, 0));
11375 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
11376 mode_line_string_list
= AREF (vector
, 2);
11377 if (! EQ (AREF (vector
, 3), Qt
))
11378 mode_line_proptrans_alist
= AREF (vector
, 3);
11379 mode_line_string_face
= AREF (vector
, 4);
11380 mode_line_string_face_prop
= AREF (vector
, 5);
11382 /* Select window before buffer, since it may change the buffer. */
11383 if (!NILP (old_window
))
11385 /* If the operation that we are unwinding had selected a window
11386 on a different frame, reset its frame-selected-window. For a
11387 text terminal, reset its top-frame if necessary. */
11388 if (!NILP (target_frame_window
))
11391 = WINDOW_FRAME (XWINDOW (target_frame_window
));
11393 if (!EQ (frame
, WINDOW_FRAME (XWINDOW (old_window
))))
11394 Fselect_window (target_frame_window
, Qt
);
11396 if (!NILP (old_top_frame
) && !EQ (old_top_frame
, frame
))
11397 Fselect_frame (old_top_frame
, Qt
);
11400 Fselect_window (old_window
, Qt
);
11403 if (!NILP (AREF (vector
, 6)))
11405 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
11406 ASET (vector
, 6, Qnil
);
11409 Vmode_line_unwind_vector
= vector
;
11413 /* Store a single character C for the frame title in mode_line_noprop_buf.
11414 Re-allocate mode_line_noprop_buf if necessary. */
11417 store_mode_line_noprop_char (char c
)
11419 /* If output position has reached the end of the allocated buffer,
11420 increase the buffer's size. */
11421 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
11423 ptrdiff_t len
= MODE_LINE_NOPROP_LEN (0);
11424 ptrdiff_t size
= len
;
11425 mode_line_noprop_buf
=
11426 xpalloc (mode_line_noprop_buf
, &size
, 1, STRING_BYTES_BOUND
, 1);
11427 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
11428 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
11431 *mode_line_noprop_ptr
++ = c
;
11435 /* Store part of a frame title in mode_line_noprop_buf, beginning at
11436 mode_line_noprop_ptr. STRING is the string to store. Do not copy
11437 characters that yield more columns than PRECISION; PRECISION <= 0
11438 means copy the whole string. Pad with spaces until FIELD_WIDTH
11439 number of characters have been copied; FIELD_WIDTH <= 0 means don't
11440 pad. Called from display_mode_element when it is used to build a
11444 store_mode_line_noprop (const char *string
, int field_width
, int precision
)
11446 const unsigned char *str
= (const unsigned char *) string
;
11448 ptrdiff_t dummy
, nbytes
;
11450 /* Copy at most PRECISION chars from STR. */
11451 nbytes
= strlen (string
);
11452 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
11454 store_mode_line_noprop_char (*str
++);
11456 /* Fill up with spaces until FIELD_WIDTH reached. */
11457 while (field_width
> 0
11458 && n
< field_width
)
11460 store_mode_line_noprop_char (' ');
11467 /***********************************************************************
11469 ***********************************************************************/
11471 #ifdef HAVE_WINDOW_SYSTEM
11473 /* Set the title of FRAME, if it has changed. The title format is
11474 Vicon_title_format if FRAME is iconified, otherwise it is
11475 frame_title_format. */
11478 x_consider_frame_title (Lisp_Object frame
)
11480 struct frame
*f
= XFRAME (frame
);
11482 if (FRAME_WINDOW_P (f
)
11483 || FRAME_MINIBUF_ONLY_P (f
)
11484 || f
->explicit_name
)
11486 /* Do we have more than one visible frame on this X display? */
11487 Lisp_Object tail
, other_frame
, fmt
;
11488 ptrdiff_t title_start
;
11492 ptrdiff_t count
= SPECPDL_INDEX ();
11494 FOR_EACH_FRAME (tail
, other_frame
)
11496 struct frame
*tf
= XFRAME (other_frame
);
11499 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
11500 && !FRAME_MINIBUF_ONLY_P (tf
)
11501 && !EQ (other_frame
, tip_frame
)
11502 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
11506 /* Set global variable indicating that multiple frames exist. */
11507 multiple_frames
= CONSP (tail
);
11509 /* Switch to the buffer of selected window of the frame. Set up
11510 mode_line_target so that display_mode_element will output into
11511 mode_line_noprop_buf; then display the title. */
11512 record_unwind_protect (unwind_format_mode_line
,
11513 format_mode_line_unwind_data
11514 (f
, current_buffer
, selected_window
, 0));
11516 Fselect_window (f
->selected_window
, Qt
);
11517 set_buffer_internal_1
11518 (XBUFFER (XWINDOW (f
->selected_window
)->contents
));
11519 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
11521 mode_line_target
= MODE_LINE_TITLE
;
11522 title_start
= MODE_LINE_NOPROP_LEN (0);
11523 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
11524 NULL
, DEFAULT_FACE_ID
);
11525 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
11526 len
= MODE_LINE_NOPROP_LEN (title_start
);
11527 title
= mode_line_noprop_buf
+ title_start
;
11528 unbind_to (count
, Qnil
);
11530 /* Set the title only if it's changed. This avoids consing in
11531 the common case where it hasn't. (If it turns out that we've
11532 already wasted too much time by walking through the list with
11533 display_mode_element, then we might need to optimize at a
11534 higher level than this.) */
11535 if (! STRINGP (f
->name
)
11536 || SBYTES (f
->name
) != len
11537 || memcmp (title
, SDATA (f
->name
), len
) != 0)
11538 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
11542 #endif /* not HAVE_WINDOW_SYSTEM */
11545 /***********************************************************************
11547 ***********************************************************************/
11549 /* Non-zero if we will not redisplay all visible windows. */
11550 #define REDISPLAY_SOME_P() \
11551 ((windows_or_buffers_changed == 0 \
11552 || windows_or_buffers_changed == REDISPLAY_SOME) \
11553 && (update_mode_lines == 0 \
11554 || update_mode_lines == REDISPLAY_SOME))
11556 /* Prepare for redisplay by updating menu-bar item lists when
11557 appropriate. This can call eval. */
11560 prepare_menu_bars (void)
11562 bool all_windows
= windows_or_buffers_changed
|| update_mode_lines
;
11563 bool some_windows
= REDISPLAY_SOME_P ();
11564 struct gcpro gcpro1
, gcpro2
;
11565 Lisp_Object tooltip_frame
;
11567 #ifdef HAVE_WINDOW_SYSTEM
11568 tooltip_frame
= tip_frame
;
11570 tooltip_frame
= Qnil
;
11573 if (FUNCTIONP (Vpre_redisplay_function
))
11575 Lisp_Object windows
= all_windows
? Qt
: Qnil
;
11576 if (all_windows
&& some_windows
)
11578 Lisp_Object ws
= window_list ();
11579 for (windows
= Qnil
; CONSP (ws
); ws
= XCDR (ws
))
11581 Lisp_Object
this = XCAR (ws
);
11582 struct window
*w
= XWINDOW (this);
11584 || XFRAME (w
->frame
)->redisplay
11585 || XBUFFER (w
->contents
)->text
->redisplay
)
11587 windows
= Fcons (this, windows
);
11591 safe__call1 (true, Vpre_redisplay_function
, windows
);
11594 /* Update all frame titles based on their buffer names, etc. We do
11595 this before the menu bars so that the buffer-menu will show the
11596 up-to-date frame titles. */
11597 #ifdef HAVE_WINDOW_SYSTEM
11600 Lisp_Object tail
, frame
;
11602 FOR_EACH_FRAME (tail
, frame
)
11604 struct frame
*f
= XFRAME (frame
);
11605 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
11609 && !XBUFFER (w
->contents
)->text
->redisplay
)
11612 if (!EQ (frame
, tooltip_frame
)
11613 && (FRAME_ICONIFIED_P (f
)
11614 || FRAME_VISIBLE_P (f
) == 1
11615 /* Exclude TTY frames that are obscured because they
11616 are not the top frame on their console. This is
11617 because x_consider_frame_title actually switches
11618 to the frame, which for TTY frames means it is
11619 marked as garbaged, and will be completely
11620 redrawn on the next redisplay cycle. This causes
11621 TTY frames to be completely redrawn, when there
11622 are more than one of them, even though nothing
11623 should be changed on display. */
11624 || (FRAME_VISIBLE_P (f
) == 2 && FRAME_WINDOW_P (f
))))
11625 x_consider_frame_title (frame
);
11628 #endif /* HAVE_WINDOW_SYSTEM */
11630 /* Update the menu bar item lists, if appropriate. This has to be
11631 done before any actual redisplay or generation of display lines. */
11635 Lisp_Object tail
, frame
;
11636 ptrdiff_t count
= SPECPDL_INDEX ();
11637 /* 1 means that update_menu_bar has run its hooks
11638 so any further calls to update_menu_bar shouldn't do so again. */
11639 int menu_bar_hooks_run
= 0;
11641 record_unwind_save_match_data ();
11643 FOR_EACH_FRAME (tail
, frame
)
11645 struct frame
*f
= XFRAME (frame
);
11646 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
11648 /* Ignore tooltip frame. */
11649 if (EQ (frame
, tooltip_frame
))
11655 && !XBUFFER (w
->contents
)->text
->redisplay
)
11658 /* If a window on this frame changed size, report that to
11659 the user and clear the size-change flag. */
11660 if (FRAME_WINDOW_SIZES_CHANGED (f
))
11662 Lisp_Object functions
;
11664 /* Clear flag first in case we get an error below. */
11665 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
11666 functions
= Vwindow_size_change_functions
;
11667 GCPRO2 (tail
, functions
);
11669 while (CONSP (functions
))
11671 if (!EQ (XCAR (functions
), Qt
))
11672 call1 (XCAR (functions
), frame
);
11673 functions
= XCDR (functions
);
11679 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
11680 #ifdef HAVE_WINDOW_SYSTEM
11681 update_tool_bar (f
, 0);
11684 if (windows_or_buffers_changed
11687 (f
, Fbuffer_modified_p (XWINDOW (f
->selected_window
)->contents
));
11692 unbind_to (count
, Qnil
);
11696 struct frame
*sf
= SELECTED_FRAME ();
11697 update_menu_bar (sf
, 1, 0);
11698 #ifdef HAVE_WINDOW_SYSTEM
11699 update_tool_bar (sf
, 1);
11705 /* Update the menu bar item list for frame F. This has to be done
11706 before we start to fill in any display lines, because it can call
11709 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
11711 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
11712 already ran the menu bar hooks for this redisplay, so there
11713 is no need to run them again. The return value is the
11714 updated value of this flag, to pass to the next call. */
11717 update_menu_bar (struct frame
*f
, int save_match_data
, int hooks_run
)
11719 Lisp_Object window
;
11720 register struct window
*w
;
11722 /* If called recursively during a menu update, do nothing. This can
11723 happen when, for instance, an activate-menubar-hook causes a
11725 if (inhibit_menubar_update
)
11728 window
= FRAME_SELECTED_WINDOW (f
);
11729 w
= XWINDOW (window
);
11731 if (FRAME_WINDOW_P (f
)
11733 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11734 || defined (HAVE_NS) || defined (USE_GTK)
11735 FRAME_EXTERNAL_MENU_BAR (f
)
11737 FRAME_MENU_BAR_LINES (f
) > 0
11739 : FRAME_MENU_BAR_LINES (f
) > 0)
11741 /* If the user has switched buffers or windows, we need to
11742 recompute to reflect the new bindings. But we'll
11743 recompute when update_mode_lines is set too; that means
11744 that people can use force-mode-line-update to request
11745 that the menu bar be recomputed. The adverse effect on
11746 the rest of the redisplay algorithm is about the same as
11747 windows_or_buffers_changed anyway. */
11748 if (windows_or_buffers_changed
11749 /* This used to test w->update_mode_line, but we believe
11750 there is no need to recompute the menu in that case. */
11751 || update_mode_lines
11752 || window_buffer_changed (w
))
11754 struct buffer
*prev
= current_buffer
;
11755 ptrdiff_t count
= SPECPDL_INDEX ();
11757 specbind (Qinhibit_menubar_update
, Qt
);
11759 set_buffer_internal_1 (XBUFFER (w
->contents
));
11760 if (save_match_data
)
11761 record_unwind_save_match_data ();
11762 if (NILP (Voverriding_local_map_menu_flag
))
11764 specbind (Qoverriding_terminal_local_map
, Qnil
);
11765 specbind (Qoverriding_local_map
, Qnil
);
11770 /* Run the Lucid hook. */
11771 safe_run_hooks (Qactivate_menubar_hook
);
11773 /* If it has changed current-menubar from previous value,
11774 really recompute the menu-bar from the value. */
11775 if (! NILP (Vlucid_menu_bar_dirty_flag
))
11776 call0 (Qrecompute_lucid_menubar
);
11778 safe_run_hooks (Qmenu_bar_update_hook
);
11783 XSETFRAME (Vmenu_updating_frame
, f
);
11784 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
11786 /* Redisplay the menu bar in case we changed it. */
11787 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11788 || defined (HAVE_NS) || defined (USE_GTK)
11789 if (FRAME_WINDOW_P (f
))
11791 #if defined (HAVE_NS)
11792 /* All frames on Mac OS share the same menubar. So only
11793 the selected frame should be allowed to set it. */
11794 if (f
== SELECTED_FRAME ())
11796 set_frame_menubar (f
, 0, 0);
11799 /* On a terminal screen, the menu bar is an ordinary screen
11800 line, and this makes it get updated. */
11801 w
->update_mode_line
= 1;
11802 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11803 /* In the non-toolkit version, the menu bar is an ordinary screen
11804 line, and this makes it get updated. */
11805 w
->update_mode_line
= 1;
11806 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11808 unbind_to (count
, Qnil
);
11809 set_buffer_internal_1 (prev
);
11816 /***********************************************************************
11818 ***********************************************************************/
11820 #ifdef HAVE_WINDOW_SYSTEM
11822 /* Select `frame' temporarily without running all the code in
11824 FIXME: Maybe do_switch_frame should be trimmed down similarly
11825 when `norecord' is set. */
11827 fast_set_selected_frame (Lisp_Object frame
)
11829 if (!EQ (selected_frame
, frame
))
11831 selected_frame
= frame
;
11832 selected_window
= XFRAME (frame
)->selected_window
;
11836 /* Update the tool-bar item list for frame F. This has to be done
11837 before we start to fill in any display lines. Called from
11838 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
11839 and restore it here. */
11842 update_tool_bar (struct frame
*f
, int save_match_data
)
11844 #if defined (USE_GTK) || defined (HAVE_NS)
11845 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
11847 int do_update
= (WINDOWP (f
->tool_bar_window
)
11848 && WINDOW_PIXEL_HEIGHT (XWINDOW (f
->tool_bar_window
)) > 0);
11853 Lisp_Object window
;
11856 window
= FRAME_SELECTED_WINDOW (f
);
11857 w
= XWINDOW (window
);
11859 /* If the user has switched buffers or windows, we need to
11860 recompute to reflect the new bindings. But we'll
11861 recompute when update_mode_lines is set too; that means
11862 that people can use force-mode-line-update to request
11863 that the menu bar be recomputed. The adverse effect on
11864 the rest of the redisplay algorithm is about the same as
11865 windows_or_buffers_changed anyway. */
11866 if (windows_or_buffers_changed
11867 || w
->update_mode_line
11868 || update_mode_lines
11869 || window_buffer_changed (w
))
11871 struct buffer
*prev
= current_buffer
;
11872 ptrdiff_t count
= SPECPDL_INDEX ();
11873 Lisp_Object frame
, new_tool_bar
;
11874 int new_n_tool_bar
;
11875 struct gcpro gcpro1
;
11877 /* Set current_buffer to the buffer of the selected
11878 window of the frame, so that we get the right local
11880 set_buffer_internal_1 (XBUFFER (w
->contents
));
11882 /* Save match data, if we must. */
11883 if (save_match_data
)
11884 record_unwind_save_match_data ();
11886 /* Make sure that we don't accidentally use bogus keymaps. */
11887 if (NILP (Voverriding_local_map_menu_flag
))
11889 specbind (Qoverriding_terminal_local_map
, Qnil
);
11890 specbind (Qoverriding_local_map
, Qnil
);
11893 GCPRO1 (new_tool_bar
);
11895 /* We must temporarily set the selected frame to this frame
11896 before calling tool_bar_items, because the calculation of
11897 the tool-bar keymap uses the selected frame (see
11898 `tool-bar-make-keymap' in tool-bar.el). */
11899 eassert (EQ (selected_window
,
11900 /* Since we only explicitly preserve selected_frame,
11901 check that selected_window would be redundant. */
11902 XFRAME (selected_frame
)->selected_window
));
11903 record_unwind_protect (fast_set_selected_frame
, selected_frame
);
11904 XSETFRAME (frame
, f
);
11905 fast_set_selected_frame (frame
);
11907 /* Build desired tool-bar items from keymaps. */
11909 = tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
11912 /* Redisplay the tool-bar if we changed it. */
11913 if (new_n_tool_bar
!= f
->n_tool_bar_items
11914 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
11916 /* Redisplay that happens asynchronously due to an expose event
11917 may access f->tool_bar_items. Make sure we update both
11918 variables within BLOCK_INPUT so no such event interrupts. */
11920 fset_tool_bar_items (f
, new_tool_bar
);
11921 f
->n_tool_bar_items
= new_n_tool_bar
;
11922 w
->update_mode_line
= 1;
11928 unbind_to (count
, Qnil
);
11929 set_buffer_internal_1 (prev
);
11934 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
11936 /* Set F->desired_tool_bar_string to a Lisp string representing frame
11937 F's desired tool-bar contents. F->tool_bar_items must have
11938 been set up previously by calling prepare_menu_bars. */
11941 build_desired_tool_bar_string (struct frame
*f
)
11943 int i
, size
, size_needed
;
11944 struct gcpro gcpro1
, gcpro2
, gcpro3
;
11945 Lisp_Object image
, plist
, props
;
11947 image
= plist
= props
= Qnil
;
11948 GCPRO3 (image
, plist
, props
);
11950 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
11951 Otherwise, make a new string. */
11953 /* The size of the string we might be able to reuse. */
11954 size
= (STRINGP (f
->desired_tool_bar_string
)
11955 ? SCHARS (f
->desired_tool_bar_string
)
11958 /* We need one space in the string for each image. */
11959 size_needed
= f
->n_tool_bar_items
;
11961 /* Reuse f->desired_tool_bar_string, if possible. */
11962 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
11963 fset_desired_tool_bar_string
11964 (f
, Fmake_string (make_number (size_needed
), make_number (' ')));
11967 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
11968 Fremove_text_properties (make_number (0), make_number (size
),
11969 props
, f
->desired_tool_bar_string
);
11972 /* Put a `display' property on the string for the images to display,
11973 put a `menu_item' property on tool-bar items with a value that
11974 is the index of the item in F's tool-bar item vector. */
11975 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
11977 #define PROP(IDX) \
11978 AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
11980 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
11981 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
11982 int hmargin
, vmargin
, relief
, idx
, end
;
11984 /* If image is a vector, choose the image according to the
11986 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
11987 if (VECTORP (image
))
11991 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
11992 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
11995 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
11996 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
11998 eassert (ASIZE (image
) >= idx
);
11999 image
= AREF (image
, idx
);
12004 /* Ignore invalid image specifications. */
12005 if (!valid_image_p (image
))
12008 /* Display the tool-bar button pressed, or depressed. */
12009 plist
= Fcopy_sequence (XCDR (image
));
12011 /* Compute margin and relief to draw. */
12012 relief
= (tool_bar_button_relief
>= 0
12013 ? tool_bar_button_relief
12014 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
12015 hmargin
= vmargin
= relief
;
12017 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
,
12018 INT_MAX
- max (hmargin
, vmargin
)))
12020 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
12021 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
12023 else if (CONSP (Vtool_bar_button_margin
))
12025 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
),
12026 INT_MAX
- hmargin
))
12027 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
12029 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
),
12030 INT_MAX
- vmargin
))
12031 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
12034 if (auto_raise_tool_bar_buttons_p
)
12036 /* Add a `:relief' property to the image spec if the item is
12040 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
12047 /* If image is selected, display it pressed, i.e. with a
12048 negative relief. If it's not selected, display it with a
12050 plist
= Fplist_put (plist
, QCrelief
,
12052 ? make_number (-relief
)
12053 : make_number (relief
)));
12058 /* Put a margin around the image. */
12059 if (hmargin
|| vmargin
)
12061 if (hmargin
== vmargin
)
12062 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
12064 plist
= Fplist_put (plist
, QCmargin
,
12065 Fcons (make_number (hmargin
),
12066 make_number (vmargin
)));
12069 /* If button is not enabled, and we don't have special images
12070 for the disabled state, make the image appear disabled by
12071 applying an appropriate algorithm to it. */
12072 if (!enabled_p
&& idx
< 0)
12073 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
12075 /* Put a `display' text property on the string for the image to
12076 display. Put a `menu-item' property on the string that gives
12077 the start of this item's properties in the tool-bar items
12079 image
= Fcons (Qimage
, plist
);
12080 props
= list4 (Qdisplay
, image
,
12081 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
12083 /* Let the last image hide all remaining spaces in the tool bar
12084 string. The string can be longer than needed when we reuse a
12085 previous string. */
12086 if (i
+ 1 == f
->n_tool_bar_items
)
12087 end
= SCHARS (f
->desired_tool_bar_string
);
12090 Fadd_text_properties (make_number (i
), make_number (end
),
12091 props
, f
->desired_tool_bar_string
);
12099 /* Display one line of the tool-bar of frame IT->f.
12101 HEIGHT specifies the desired height of the tool-bar line.
12102 If the actual height of the glyph row is less than HEIGHT, the
12103 row's height is increased to HEIGHT, and the icons are centered
12104 vertically in the new height.
12106 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
12107 count a final empty row in case the tool-bar width exactly matches
12112 display_tool_bar_line (struct it
*it
, int height
)
12114 struct glyph_row
*row
= it
->glyph_row
;
12115 int max_x
= it
->last_visible_x
;
12116 struct glyph
*last
;
12118 /* Don't extend on a previously drawn tool bar items (Bug#16058). */
12119 clear_glyph_row (row
);
12120 row
->enabled_p
= true;
12121 row
->y
= it
->current_y
;
12123 /* Note that this isn't made use of if the face hasn't a box,
12124 so there's no need to check the face here. */
12125 it
->start_of_box_run_p
= 1;
12127 while (it
->current_x
< max_x
)
12129 int x
, n_glyphs_before
, i
, nglyphs
;
12130 struct it it_before
;
12132 /* Get the next display element. */
12133 if (!get_next_display_element (it
))
12135 /* Don't count empty row if we are counting needed tool-bar lines. */
12136 if (height
< 0 && !it
->hpos
)
12141 /* Produce glyphs. */
12142 n_glyphs_before
= row
->used
[TEXT_AREA
];
12145 PRODUCE_GLYPHS (it
);
12147 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
12149 x
= it_before
.current_x
;
12150 while (i
< nglyphs
)
12152 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
12154 if (x
+ glyph
->pixel_width
> max_x
)
12156 /* Glyph doesn't fit on line. Backtrack. */
12157 row
->used
[TEXT_AREA
] = n_glyphs_before
;
12159 /* If this is the only glyph on this line, it will never fit on the
12160 tool-bar, so skip it. But ensure there is at least one glyph,
12161 so we don't accidentally disable the tool-bar. */
12162 if (n_glyphs_before
== 0
12163 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
12169 x
+= glyph
->pixel_width
;
12173 /* Stop at line end. */
12174 if (ITERATOR_AT_END_OF_LINE_P (it
))
12177 set_iterator_to_next (it
, 1);
12182 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
12184 /* Use default face for the border below the tool bar.
12186 FIXME: When auto-resize-tool-bars is grow-only, there is
12187 no additional border below the possibly empty tool-bar lines.
12188 So to make the extra empty lines look "normal", we have to
12189 use the tool-bar face for the border too. */
12190 if (!MATRIX_ROW_DISPLAYS_TEXT_P (row
)
12191 && !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
12192 it
->face_id
= DEFAULT_FACE_ID
;
12194 extend_face_to_end_of_line (it
);
12195 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
12196 last
->right_box_line_p
= 1;
12197 if (last
== row
->glyphs
[TEXT_AREA
])
12198 last
->left_box_line_p
= 1;
12200 /* Make line the desired height and center it vertically. */
12201 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
12203 /* Don't add more than one line height. */
12204 height
%= FRAME_LINE_HEIGHT (it
->f
);
12205 it
->max_ascent
+= height
/ 2;
12206 it
->max_descent
+= (height
+ 1) / 2;
12209 compute_line_metrics (it
);
12211 /* If line is empty, make it occupy the rest of the tool-bar. */
12212 if (!MATRIX_ROW_DISPLAYS_TEXT_P (row
))
12214 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
12215 row
->visible_height
= row
->height
;
12216 row
->ascent
= row
->phys_ascent
= 0;
12217 row
->extra_line_spacing
= 0;
12220 row
->full_width_p
= 1;
12221 row
->continued_p
= 0;
12222 row
->truncated_on_left_p
= 0;
12223 row
->truncated_on_right_p
= 0;
12225 it
->current_x
= it
->hpos
= 0;
12226 it
->current_y
+= row
->height
;
12232 /* Max tool-bar height. Basically, this is what makes all other windows
12233 disappear when the frame gets too small. Rethink this! */
12235 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
12236 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
12238 /* Value is the number of pixels needed to make all tool-bar items of
12239 frame F visible. The actual number of glyph rows needed is
12240 returned in *N_ROWS if non-NULL. */
12243 tool_bar_height (struct frame
*f
, int *n_rows
, bool pixelwise
)
12245 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12247 /* tool_bar_height is called from redisplay_tool_bar after building
12248 the desired matrix, so use (unused) mode-line row as temporary row to
12249 avoid destroying the first tool-bar row. */
12250 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
12252 /* Initialize an iterator for iteration over
12253 F->desired_tool_bar_string in the tool-bar window of frame F. */
12254 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
12255 it
.first_visible_x
= 0;
12256 it
.last_visible_x
= WINDOW_PIXEL_WIDTH (w
);
12257 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
12258 it
.paragraph_embedding
= L2R
;
12260 while (!ITERATOR_AT_END_P (&it
))
12262 clear_glyph_row (temp_row
);
12263 it
.glyph_row
= temp_row
;
12264 display_tool_bar_line (&it
, -1);
12266 clear_glyph_row (temp_row
);
12268 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
12270 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
12273 return it
.current_y
;
12275 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
12278 #endif /* !USE_GTK && !HAVE_NS */
12280 DEFUN ("tool-bar-height", Ftool_bar_height
, Stool_bar_height
,
12282 doc
: /* Return the number of lines occupied by the tool bar of FRAME.
12283 If FRAME is nil or omitted, use the selected frame. Optional argument
12284 PIXELWISE non-nil means return the height of the tool bar in pixels. */)
12285 (Lisp_Object frame
, Lisp_Object pixelwise
)
12289 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
12290 struct frame
*f
= decode_any_frame (frame
);
12292 if (WINDOWP (f
->tool_bar_window
)
12293 && WINDOW_PIXEL_HEIGHT (XWINDOW (f
->tool_bar_window
)) > 0)
12295 update_tool_bar (f
, 1);
12296 if (f
->n_tool_bar_items
)
12298 build_desired_tool_bar_string (f
);
12299 height
= tool_bar_height (f
, NULL
, NILP (pixelwise
) ? 0 : 1);
12304 return make_number (height
);
12308 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
12309 height should be changed. */
12312 redisplay_tool_bar (struct frame
*f
)
12314 #if defined (USE_GTK) || defined (HAVE_NS)
12316 if (FRAME_EXTERNAL_TOOL_BAR (f
))
12317 update_frame_tool_bar (f
);
12320 #else /* !USE_GTK && !HAVE_NS */
12324 struct glyph_row
*row
;
12326 /* If frame hasn't a tool-bar window or if it is zero-height, don't
12327 do anything. This means you must start with tool-bar-lines
12328 non-zero to get the auto-sizing effect. Or in other words, you
12329 can turn off tool-bars by specifying tool-bar-lines zero. */
12330 if (!WINDOWP (f
->tool_bar_window
)
12331 || (w
= XWINDOW (f
->tool_bar_window
),
12332 WINDOW_PIXEL_HEIGHT (w
) == 0))
12335 /* Set up an iterator for the tool-bar window. */
12336 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
12337 it
.first_visible_x
= 0;
12338 it
.last_visible_x
= WINDOW_PIXEL_WIDTH (w
);
12339 row
= it
.glyph_row
;
12341 /* Build a string that represents the contents of the tool-bar. */
12342 build_desired_tool_bar_string (f
);
12343 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
12344 /* FIXME: This should be controlled by a user option. But it
12345 doesn't make sense to have an R2L tool bar if the menu bar cannot
12346 be drawn also R2L, and making the menu bar R2L is tricky due
12347 toolkit-specific code that implements it. If an R2L tool bar is
12348 ever supported, display_tool_bar_line should also be augmented to
12349 call unproduce_glyphs like display_line and display_string
12351 it
.paragraph_embedding
= L2R
;
12353 if (f
->n_tool_bar_rows
== 0)
12355 int new_height
= tool_bar_height (f
, &f
->n_tool_bar_rows
, 1);
12357 if (new_height
!= WINDOW_PIXEL_HEIGHT (w
))
12360 int new_lines
= ((new_height
+ FRAME_LINE_HEIGHT (f
) - 1)
12361 / FRAME_LINE_HEIGHT (f
));
12363 XSETFRAME (frame
, f
);
12364 Fmodify_frame_parameters (frame
,
12365 list1 (Fcons (Qtool_bar_lines
,
12366 make_number (new_lines
))));
12367 /* Always do that now. */
12368 clear_glyph_matrix (w
->desired_matrix
);
12369 f
->fonts_changed
= 1;
12374 /* Display as many lines as needed to display all tool-bar items. */
12376 if (f
->n_tool_bar_rows
> 0)
12378 int border
, rows
, height
, extra
;
12380 if (TYPE_RANGED_INTEGERP (int, Vtool_bar_border
))
12381 border
= XINT (Vtool_bar_border
);
12382 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
12383 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
12384 else if (EQ (Vtool_bar_border
, Qborder_width
))
12385 border
= f
->border_width
;
12391 rows
= f
->n_tool_bar_rows
;
12392 height
= max (1, (it
.last_visible_y
- border
) / rows
);
12393 extra
= it
.last_visible_y
- border
- height
* rows
;
12395 while (it
.current_y
< it
.last_visible_y
)
12398 if (extra
> 0 && rows
-- > 0)
12400 h
= (extra
+ rows
- 1) / rows
;
12403 display_tool_bar_line (&it
, height
+ h
);
12408 while (it
.current_y
< it
.last_visible_y
)
12409 display_tool_bar_line (&it
, 0);
12412 /* It doesn't make much sense to try scrolling in the tool-bar
12413 window, so don't do it. */
12414 w
->desired_matrix
->no_scrolling_p
= 1;
12415 w
->must_be_updated_p
= 1;
12417 if (!NILP (Vauto_resize_tool_bars
))
12419 /* Do we really allow the toolbar to occupy the whole frame? */
12420 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
12421 int change_height_p
= 0;
12423 /* If we couldn't display everything, change the tool-bar's
12424 height if there is room for more. */
12425 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
12426 && it
.current_y
< max_tool_bar_height
)
12427 change_height_p
= 1;
12429 /* We subtract 1 because display_tool_bar_line advances the
12430 glyph_row pointer before returning to its caller. We want to
12431 examine the last glyph row produced by
12432 display_tool_bar_line. */
12433 row
= it
.glyph_row
- 1;
12435 /* If there are blank lines at the end, except for a partially
12436 visible blank line at the end that is smaller than
12437 FRAME_LINE_HEIGHT, change the tool-bar's height. */
12438 if (!MATRIX_ROW_DISPLAYS_TEXT_P (row
)
12439 && row
->height
>= FRAME_LINE_HEIGHT (f
))
12440 change_height_p
= 1;
12442 /* If row displays tool-bar items, but is partially visible,
12443 change the tool-bar's height. */
12444 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
12445 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
12446 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
12447 change_height_p
= 1;
12449 /* Resize windows as needed by changing the `tool-bar-lines'
12450 frame parameter. */
12451 if (change_height_p
)
12455 int new_height
= tool_bar_height (f
, &nrows
, 1);
12457 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
12458 && !f
->minimize_tool_bar_window_p
)
12459 ? (new_height
> WINDOW_PIXEL_HEIGHT (w
))
12460 : (new_height
!= WINDOW_PIXEL_HEIGHT (w
)));
12461 f
->minimize_tool_bar_window_p
= 0;
12463 if (change_height_p
)
12465 /* Current size of the tool-bar window in canonical line
12467 int old_lines
= WINDOW_TOTAL_LINES (w
);
12468 /* Required size of the tool-bar window in canonical
12470 int new_lines
= ((new_height
+ FRAME_LINE_HEIGHT (f
) - 1)
12471 / FRAME_LINE_HEIGHT (f
));
12472 /* Maximum size of the tool-bar window in canonical line
12473 units that this frame can allow. */
12475 WINDOW_TOTAL_LINES (XWINDOW (FRAME_ROOT_WINDOW (f
))) - 1;
12477 /* Don't try to change the tool-bar window size and set
12478 the fonts_changed flag unless really necessary. That
12479 flag causes redisplay to give up and retry
12480 redisplaying the frame from scratch, so setting it
12481 unnecessarily can lead to nasty redisplay loops. */
12482 if (new_lines
<= max_lines
12483 && eabs (new_lines
- old_lines
) >= 1)
12485 XSETFRAME (frame
, f
);
12486 Fmodify_frame_parameters (frame
,
12487 list1 (Fcons (Qtool_bar_lines
,
12488 make_number (new_lines
))));
12489 clear_glyph_matrix (w
->desired_matrix
);
12490 f
->n_tool_bar_rows
= nrows
;
12491 f
->fonts_changed
= 1;
12498 f
->minimize_tool_bar_window_p
= 0;
12501 #endif /* USE_GTK || HAVE_NS */
12504 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
12506 /* Get information about the tool-bar item which is displayed in GLYPH
12507 on frame F. Return in *PROP_IDX the index where tool-bar item
12508 properties start in F->tool_bar_items. Value is zero if
12509 GLYPH doesn't display a tool-bar item. */
12512 tool_bar_item_info (struct frame
*f
, struct glyph
*glyph
, int *prop_idx
)
12518 /* This function can be called asynchronously, which means we must
12519 exclude any possibility that Fget_text_property signals an
12521 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
12522 charpos
= max (0, charpos
);
12524 /* Get the text property `menu-item' at pos. The value of that
12525 property is the start index of this item's properties in
12526 F->tool_bar_items. */
12527 prop
= Fget_text_property (make_number (charpos
),
12528 Qmenu_item
, f
->current_tool_bar_string
);
12529 if (INTEGERP (prop
))
12531 *prop_idx
= XINT (prop
);
12541 /* Get information about the tool-bar item at position X/Y on frame F.
12542 Return in *GLYPH a pointer to the glyph of the tool-bar item in
12543 the current matrix of the tool-bar window of F, or NULL if not
12544 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
12545 item in F->tool_bar_items. Value is
12547 -1 if X/Y is not on a tool-bar item
12548 0 if X/Y is on the same item that was highlighted before.
12552 get_tool_bar_item (struct frame
*f
, int x
, int y
, struct glyph
**glyph
,
12553 int *hpos
, int *vpos
, int *prop_idx
)
12555 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12556 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12559 /* Find the glyph under X/Y. */
12560 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
12561 if (*glyph
== NULL
)
12564 /* Get the start of this tool-bar item's properties in
12565 f->tool_bar_items. */
12566 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
12569 /* Is mouse on the highlighted item? */
12570 if (EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)
12571 && *vpos
>= hlinfo
->mouse_face_beg_row
12572 && *vpos
<= hlinfo
->mouse_face_end_row
12573 && (*vpos
> hlinfo
->mouse_face_beg_row
12574 || *hpos
>= hlinfo
->mouse_face_beg_col
)
12575 && (*vpos
< hlinfo
->mouse_face_end_row
12576 || *hpos
< hlinfo
->mouse_face_end_col
12577 || hlinfo
->mouse_face_past_end
))
12585 Handle mouse button event on the tool-bar of frame F, at
12586 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
12587 0 for button release. MODIFIERS is event modifiers for button
12591 handle_tool_bar_click (struct frame
*f
, int x
, int y
, int down_p
,
12594 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12595 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12596 int hpos
, vpos
, prop_idx
;
12597 struct glyph
*glyph
;
12598 Lisp_Object enabled_p
;
12601 /* If not on the highlighted tool-bar item, and mouse-highlight is
12602 non-nil, return. This is so we generate the tool-bar button
12603 click only when the mouse button is released on the same item as
12604 where it was pressed. However, when mouse-highlight is disabled,
12605 generate the click when the button is released regardless of the
12606 highlight, since tool-bar items are not highlighted in that
12608 frame_to_window_pixel_xy (w
, &x
, &y
);
12609 ts
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
12611 || (ts
!= 0 && !NILP (Vmouse_highlight
)))
12614 /* When mouse-highlight is off, generate the click for the item
12615 where the button was pressed, disregarding where it was
12617 if (NILP (Vmouse_highlight
) && !down_p
)
12618 prop_idx
= f
->last_tool_bar_item
;
12620 /* If item is disabled, do nothing. */
12621 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12622 if (NILP (enabled_p
))
12627 /* Show item in pressed state. */
12628 if (!NILP (Vmouse_highlight
))
12629 show_mouse_face (hlinfo
, DRAW_IMAGE_SUNKEN
);
12630 f
->last_tool_bar_item
= prop_idx
;
12634 Lisp_Object key
, frame
;
12635 struct input_event event
;
12636 EVENT_INIT (event
);
12638 /* Show item in released state. */
12639 if (!NILP (Vmouse_highlight
))
12640 show_mouse_face (hlinfo
, DRAW_IMAGE_RAISED
);
12642 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
12644 XSETFRAME (frame
, f
);
12645 event
.kind
= TOOL_BAR_EVENT
;
12646 event
.frame_or_window
= frame
;
12648 kbd_buffer_store_event (&event
);
12650 event
.kind
= TOOL_BAR_EVENT
;
12651 event
.frame_or_window
= frame
;
12653 event
.modifiers
= modifiers
;
12654 kbd_buffer_store_event (&event
);
12655 f
->last_tool_bar_item
= -1;
12660 /* Possibly highlight a tool-bar item on frame F when mouse moves to
12661 tool-bar window-relative coordinates X/Y. Called from
12662 note_mouse_highlight. */
12665 note_tool_bar_highlight (struct frame
*f
, int x
, int y
)
12667 Lisp_Object window
= f
->tool_bar_window
;
12668 struct window
*w
= XWINDOW (window
);
12669 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
12670 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12672 struct glyph
*glyph
;
12673 struct glyph_row
*row
;
12675 Lisp_Object enabled_p
;
12677 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
12678 int mouse_down_p
, rc
;
12680 /* Function note_mouse_highlight is called with negative X/Y
12681 values when mouse moves outside of the frame. */
12682 if (x
<= 0 || y
<= 0)
12684 clear_mouse_face (hlinfo
);
12688 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
12691 /* Not on tool-bar item. */
12692 clear_mouse_face (hlinfo
);
12696 /* On same tool-bar item as before. */
12697 goto set_help_echo
;
12699 clear_mouse_face (hlinfo
);
12701 /* Mouse is down, but on different tool-bar item? */
12702 mouse_down_p
= (x_mouse_grabbed (dpyinfo
)
12703 && f
== dpyinfo
->last_mouse_frame
);
12705 if (mouse_down_p
&& f
->last_tool_bar_item
!= prop_idx
)
12708 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
12710 /* If tool-bar item is not enabled, don't highlight it. */
12711 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12712 if (!NILP (enabled_p
) && !NILP (Vmouse_highlight
))
12714 /* Compute the x-position of the glyph. In front and past the
12715 image is a space. We include this in the highlighted area. */
12716 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
12717 for (i
= x
= 0; i
< hpos
; ++i
)
12718 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
12720 /* Record this as the current active region. */
12721 hlinfo
->mouse_face_beg_col
= hpos
;
12722 hlinfo
->mouse_face_beg_row
= vpos
;
12723 hlinfo
->mouse_face_beg_x
= x
;
12724 hlinfo
->mouse_face_past_end
= 0;
12726 hlinfo
->mouse_face_end_col
= hpos
+ 1;
12727 hlinfo
->mouse_face_end_row
= vpos
;
12728 hlinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
12729 hlinfo
->mouse_face_window
= window
;
12730 hlinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
12732 /* Display it as active. */
12733 show_mouse_face (hlinfo
, draw
);
12738 /* Set help_echo_string to a help string to display for this tool-bar item.
12739 XTread_socket does the rest. */
12740 help_echo_object
= help_echo_window
= Qnil
;
12741 help_echo_pos
= -1;
12742 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
12743 if (NILP (help_echo_string
))
12744 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
12747 #endif /* !USE_GTK && !HAVE_NS */
12749 #endif /* HAVE_WINDOW_SYSTEM */
12753 /************************************************************************
12754 Horizontal scrolling
12755 ************************************************************************/
12757 static int hscroll_window_tree (Lisp_Object
);
12758 static int hscroll_windows (Lisp_Object
);
12760 /* For all leaf windows in the window tree rooted at WINDOW, set their
12761 hscroll value so that PT is (i) visible in the window, and (ii) so
12762 that it is not within a certain margin at the window's left and
12763 right border. Value is non-zero if any window's hscroll has been
12767 hscroll_window_tree (Lisp_Object window
)
12769 int hscrolled_p
= 0;
12770 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
12771 int hscroll_step_abs
= 0;
12772 double hscroll_step_rel
= 0;
12774 if (hscroll_relative_p
)
12776 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
12777 if (hscroll_step_rel
< 0)
12779 hscroll_relative_p
= 0;
12780 hscroll_step_abs
= 0;
12783 else if (TYPE_RANGED_INTEGERP (int, Vhscroll_step
))
12785 hscroll_step_abs
= XINT (Vhscroll_step
);
12786 if (hscroll_step_abs
< 0)
12787 hscroll_step_abs
= 0;
12790 hscroll_step_abs
= 0;
12792 while (WINDOWP (window
))
12794 struct window
*w
= XWINDOW (window
);
12796 if (WINDOWP (w
->contents
))
12797 hscrolled_p
|= hscroll_window_tree (w
->contents
);
12798 else if (w
->cursor
.vpos
>= 0)
12801 int text_area_width
;
12802 struct glyph_row
*cursor_row
;
12803 struct glyph_row
*bottom_row
;
12806 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->desired_matrix
, w
);
12807 if (w
->cursor
.vpos
< bottom_row
- w
->desired_matrix
->rows
)
12808 cursor_row
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
12810 cursor_row
= bottom_row
- 1;
12812 if (!cursor_row
->enabled_p
)
12814 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
12815 if (w
->cursor
.vpos
< bottom_row
- w
->current_matrix
->rows
)
12816 cursor_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
12818 cursor_row
= bottom_row
- 1;
12820 row_r2l_p
= cursor_row
->reversed_p
;
12822 text_area_width
= window_box_width (w
, TEXT_AREA
);
12824 /* Scroll when cursor is inside this scroll margin. */
12825 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
12827 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode
, w
->contents
))
12828 /* For left-to-right rows, hscroll when cursor is either
12829 (i) inside the right hscroll margin, or (ii) if it is
12830 inside the left margin and the window is already
12834 && w
->cursor
.x
<= h_margin
)
12835 || (cursor_row
->enabled_p
12836 && cursor_row
->truncated_on_right_p
12837 && (w
->cursor
.x
>= text_area_width
- h_margin
))))
12838 /* For right-to-left rows, the logic is similar,
12839 except that rules for scrolling to left and right
12840 are reversed. E.g., if cursor.x <= h_margin, we
12841 need to hscroll "to the right" unconditionally,
12842 and that will scroll the screen to the left so as
12843 to reveal the next portion of the row. */
12845 && ((cursor_row
->enabled_p
12846 /* FIXME: It is confusing to set the
12847 truncated_on_right_p flag when R2L rows
12848 are actually truncated on the left. */
12849 && cursor_row
->truncated_on_right_p
12850 && w
->cursor
.x
<= h_margin
)
12852 && (w
->cursor
.x
>= text_area_width
- h_margin
))))))
12856 struct buffer
*saved_current_buffer
;
12860 /* Find point in a display of infinite width. */
12861 saved_current_buffer
= current_buffer
;
12862 current_buffer
= XBUFFER (w
->contents
);
12864 if (w
== XWINDOW (selected_window
))
12867 pt
= clip_to_bounds (BEGV
, marker_position (w
->pointm
), ZV
);
12869 /* Move iterator to pt starting at cursor_row->start in
12870 a line with infinite width. */
12871 init_to_row_start (&it
, w
, cursor_row
);
12872 it
.last_visible_x
= INFINITY
;
12873 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
12874 current_buffer
= saved_current_buffer
;
12876 /* Position cursor in window. */
12877 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
12878 hscroll
= max (0, (it
.current_x
12879 - (ITERATOR_AT_END_OF_LINE_P (&it
)
12880 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
12881 : (text_area_width
/ 2))))
12882 / FRAME_COLUMN_WIDTH (it
.f
);
12883 else if ((!row_r2l_p
12884 && w
->cursor
.x
>= text_area_width
- h_margin
)
12885 || (row_r2l_p
&& w
->cursor
.x
<= h_margin
))
12887 if (hscroll_relative_p
)
12888 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
12891 wanted_x
= text_area_width
12892 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12895 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12899 if (hscroll_relative_p
)
12900 wanted_x
= text_area_width
* hscroll_step_rel
12903 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12906 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12908 hscroll
= max (hscroll
, w
->min_hscroll
);
12910 /* Don't prevent redisplay optimizations if hscroll
12911 hasn't changed, as it will unnecessarily slow down
12913 if (w
->hscroll
!= hscroll
)
12915 XBUFFER (w
->contents
)->prevent_redisplay_optimizations_p
= 1;
12916 w
->hscroll
= hscroll
;
12925 /* Value is non-zero if hscroll of any leaf window has been changed. */
12926 return hscrolled_p
;
12930 /* Set hscroll so that cursor is visible and not inside horizontal
12931 scroll margins for all windows in the tree rooted at WINDOW. See
12932 also hscroll_window_tree above. Value is non-zero if any window's
12933 hscroll has been changed. If it has, desired matrices on the frame
12934 of WINDOW are cleared. */
12937 hscroll_windows (Lisp_Object window
)
12939 int hscrolled_p
= hscroll_window_tree (window
);
12941 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
12942 return hscrolled_p
;
12947 /************************************************************************
12949 ************************************************************************/
12951 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
12952 to a non-zero value. This is sometimes handy to have in a debugger
12957 /* First and last unchanged row for try_window_id. */
12959 static int debug_first_unchanged_at_end_vpos
;
12960 static int debug_last_unchanged_at_beg_vpos
;
12962 /* Delta vpos and y. */
12964 static int debug_dvpos
, debug_dy
;
12966 /* Delta in characters and bytes for try_window_id. */
12968 static ptrdiff_t debug_delta
, debug_delta_bytes
;
12970 /* Values of window_end_pos and window_end_vpos at the end of
12973 static ptrdiff_t debug_end_vpos
;
12975 /* Append a string to W->desired_matrix->method. FMT is a printf
12976 format string. If trace_redisplay_p is true also printf the
12977 resulting string to stderr. */
12979 static void debug_method_add (struct window
*, char const *, ...)
12980 ATTRIBUTE_FORMAT_PRINTF (2, 3);
12983 debug_method_add (struct window
*w
, char const *fmt
, ...)
12986 char *method
= w
->desired_matrix
->method
;
12987 int len
= strlen (method
);
12988 int size
= sizeof w
->desired_matrix
->method
;
12989 int remaining
= size
- len
- 1;
12992 if (len
&& remaining
)
12995 --remaining
, ++len
;
12998 va_start (ap
, fmt
);
12999 vsnprintf (method
+ len
, remaining
+ 1, fmt
, ap
);
13002 if (trace_redisplay_p
)
13003 fprintf (stderr
, "%p (%s): %s\n",
13005 ((BUFFERP (w
->contents
)
13006 && STRINGP (BVAR (XBUFFER (w
->contents
), name
)))
13007 ? SSDATA (BVAR (XBUFFER (w
->contents
), name
))
13012 #endif /* GLYPH_DEBUG */
13015 /* Value is non-zero if all changes in window W, which displays
13016 current_buffer, are in the text between START and END. START is a
13017 buffer position, END is given as a distance from Z. Used in
13018 redisplay_internal for display optimization. */
13021 text_outside_line_unchanged_p (struct window
*w
,
13022 ptrdiff_t start
, ptrdiff_t end
)
13024 int unchanged_p
= 1;
13026 /* If text or overlays have changed, see where. */
13027 if (window_outdated (w
))
13029 /* Gap in the line? */
13030 if (GPT
< start
|| Z
- GPT
< end
)
13033 /* Changes start in front of the line, or end after it? */
13035 && (BEG_UNCHANGED
< start
- 1
13036 || END_UNCHANGED
< end
))
13039 /* If selective display, can't optimize if changes start at the
13040 beginning of the line. */
13042 && INTEGERP (BVAR (current_buffer
, selective_display
))
13043 && XINT (BVAR (current_buffer
, selective_display
)) > 0
13044 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
13047 /* If there are overlays at the start or end of the line, these
13048 may have overlay strings with newlines in them. A change at
13049 START, for instance, may actually concern the display of such
13050 overlay strings as well, and they are displayed on different
13051 lines. So, quickly rule out this case. (For the future, it
13052 might be desirable to implement something more telling than
13053 just BEG/END_UNCHANGED.) */
13056 if (BEG
+ BEG_UNCHANGED
== start
13057 && overlay_touches_p (start
))
13059 if (END_UNCHANGED
== end
13060 && overlay_touches_p (Z
- end
))
13064 /* Under bidi reordering, adding or deleting a character in the
13065 beginning of a paragraph, before the first strong directional
13066 character, can change the base direction of the paragraph (unless
13067 the buffer specifies a fixed paragraph direction), which will
13068 require to redisplay the whole paragraph. It might be worthwhile
13069 to find the paragraph limits and widen the range of redisplayed
13070 lines to that, but for now just give up this optimization. */
13071 if (!NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
))
13072 && NILP (BVAR (XBUFFER (w
->contents
), bidi_paragraph_direction
)))
13076 return unchanged_p
;
13080 /* Do a frame update, taking possible shortcuts into account. This is
13081 the main external entry point for redisplay.
13083 If the last redisplay displayed an echo area message and that message
13084 is no longer requested, we clear the echo area or bring back the
13085 mini-buffer if that is in use. */
13090 redisplay_internal ();
13095 overlay_arrow_string_or_property (Lisp_Object var
)
13099 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
13102 return Voverlay_arrow_string
;
13105 /* Return 1 if there are any overlay-arrows in current_buffer. */
13107 overlay_arrow_in_current_buffer_p (void)
13111 for (vlist
= Voverlay_arrow_variable_list
;
13113 vlist
= XCDR (vlist
))
13115 Lisp_Object var
= XCAR (vlist
);
13118 if (!SYMBOLP (var
))
13120 val
= find_symbol_value (var
);
13122 && current_buffer
== XMARKER (val
)->buffer
)
13129 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
13133 overlay_arrows_changed_p (void)
13137 for (vlist
= Voverlay_arrow_variable_list
;
13139 vlist
= XCDR (vlist
))
13141 Lisp_Object var
= XCAR (vlist
);
13142 Lisp_Object val
, pstr
;
13144 if (!SYMBOLP (var
))
13146 val
= find_symbol_value (var
);
13147 if (!MARKERP (val
))
13149 if (! EQ (COERCE_MARKER (val
),
13150 Fget (var
, Qlast_arrow_position
))
13151 || ! (pstr
= overlay_arrow_string_or_property (var
),
13152 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
13158 /* Mark overlay arrows to be updated on next redisplay. */
13161 update_overlay_arrows (int up_to_date
)
13165 for (vlist
= Voverlay_arrow_variable_list
;
13167 vlist
= XCDR (vlist
))
13169 Lisp_Object var
= XCAR (vlist
);
13171 if (!SYMBOLP (var
))
13174 if (up_to_date
> 0)
13176 Lisp_Object val
= find_symbol_value (var
);
13177 Fput (var
, Qlast_arrow_position
,
13178 COERCE_MARKER (val
));
13179 Fput (var
, Qlast_arrow_string
,
13180 overlay_arrow_string_or_property (var
));
13182 else if (up_to_date
< 0
13183 || !NILP (Fget (var
, Qlast_arrow_position
)))
13185 Fput (var
, Qlast_arrow_position
, Qt
);
13186 Fput (var
, Qlast_arrow_string
, Qt
);
13192 /* Return overlay arrow string to display at row.
13193 Return integer (bitmap number) for arrow bitmap in left fringe.
13194 Return nil if no overlay arrow. */
13197 overlay_arrow_at_row (struct it
*it
, struct glyph_row
*row
)
13201 for (vlist
= Voverlay_arrow_variable_list
;
13203 vlist
= XCDR (vlist
))
13205 Lisp_Object var
= XCAR (vlist
);
13208 if (!SYMBOLP (var
))
13211 val
= find_symbol_value (var
);
13214 && current_buffer
== XMARKER (val
)->buffer
13215 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
13217 if (FRAME_WINDOW_P (it
->f
)
13218 /* FIXME: if ROW->reversed_p is set, this should test
13219 the right fringe, not the left one. */
13220 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
13222 #ifdef HAVE_WINDOW_SYSTEM
13223 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
13226 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
13227 return make_number (fringe_bitmap
);
13230 return make_number (-1); /* Use default arrow bitmap. */
13232 return overlay_arrow_string_or_property (var
);
13239 /* Return 1 if point moved out of or into a composition. Otherwise
13240 return 0. PREV_BUF and PREV_PT are the last point buffer and
13241 position. BUF and PT are the current point buffer and position. */
13244 check_point_in_composition (struct buffer
*prev_buf
, ptrdiff_t prev_pt
,
13245 struct buffer
*buf
, ptrdiff_t pt
)
13247 ptrdiff_t start
, end
;
13249 Lisp_Object buffer
;
13251 XSETBUFFER (buffer
, buf
);
13252 /* Check a composition at the last point if point moved within the
13254 if (prev_buf
== buf
)
13257 /* Point didn't move. */
13260 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
13261 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
13262 && composition_valid_p (start
, end
, prop
)
13263 && start
< prev_pt
&& end
> prev_pt
)
13264 /* The last point was within the composition. Return 1 iff
13265 point moved out of the composition. */
13266 return (pt
<= start
|| pt
>= end
);
13269 /* Check a composition at the current point. */
13270 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
13271 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
13272 && composition_valid_p (start
, end
, prop
)
13273 && start
< pt
&& end
> pt
);
13276 /* Reconsider the clip changes of buffer which is displayed in W. */
13279 reconsider_clip_changes (struct window
*w
)
13281 struct buffer
*b
= XBUFFER (w
->contents
);
13283 if (b
->clip_changed
13284 && w
->window_end_valid
13285 && w
->current_matrix
->buffer
== b
13286 && w
->current_matrix
->zv
== BUF_ZV (b
)
13287 && w
->current_matrix
->begv
== BUF_BEGV (b
))
13288 b
->clip_changed
= 0;
13290 /* If display wasn't paused, and W is not a tool bar window, see if
13291 point has been moved into or out of a composition. In that case,
13292 we set b->clip_changed to 1 to force updating the screen. If
13293 b->clip_changed has already been set to 1, we can skip this
13295 if (!b
->clip_changed
&& w
->window_end_valid
)
13297 ptrdiff_t pt
= (w
== XWINDOW (selected_window
)
13298 ? PT
: marker_position (w
->pointm
));
13300 if ((w
->current_matrix
->buffer
!= b
|| pt
!= w
->last_point
)
13301 && check_point_in_composition (w
->current_matrix
->buffer
,
13302 w
->last_point
, b
, pt
))
13303 b
->clip_changed
= 1;
13308 propagate_buffer_redisplay (void)
13309 { /* Resetting b->text->redisplay is problematic!
13310 We can't just reset it in the case that some window that displays
13311 it has not been redisplayed; and such a window can stay
13312 unredisplayed for a long time if it's currently invisible.
13313 But we do want to reset it at the end of redisplay otherwise
13314 its displayed windows will keep being redisplayed over and over
13316 So we copy all b->text->redisplay flags up to their windows here,
13317 such that mark_window_display_accurate can safely reset
13318 b->text->redisplay. */
13319 Lisp_Object ws
= window_list ();
13320 for (; CONSP (ws
); ws
= XCDR (ws
))
13322 struct window
*thisw
= XWINDOW (XCAR (ws
));
13323 struct buffer
*thisb
= XBUFFER (thisw
->contents
);
13324 if (thisb
->text
->redisplay
)
13325 thisw
->redisplay
= true;
13329 #define STOP_POLLING \
13330 do { if (! polling_stopped_here) stop_polling (); \
13331 polling_stopped_here = 1; } while (0)
13333 #define RESUME_POLLING \
13334 do { if (polling_stopped_here) start_polling (); \
13335 polling_stopped_here = 0; } while (0)
13338 /* Perhaps in the future avoid recentering windows if it
13339 is not necessary; currently that causes some problems. */
13342 redisplay_internal (void)
13344 struct window
*w
= XWINDOW (selected_window
);
13348 bool must_finish
= 0, match_p
;
13349 struct text_pos tlbufpos
, tlendpos
;
13350 int number_of_visible_frames
;
13353 int polling_stopped_here
= 0;
13354 Lisp_Object tail
, frame
;
13356 /* True means redisplay has to consider all windows on all
13357 frames. False, only selected_window is considered. */
13358 bool consider_all_windows_p
;
13360 /* True means redisplay has to redisplay the miniwindow. */
13361 bool update_miniwindow_p
= false;
13363 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
13365 /* No redisplay if running in batch mode or frame is not yet fully
13366 initialized, or redisplay is explicitly turned off by setting
13367 Vinhibit_redisplay. */
13368 if (FRAME_INITIAL_P (SELECTED_FRAME ())
13369 || !NILP (Vinhibit_redisplay
))
13372 /* Don't examine these until after testing Vinhibit_redisplay.
13373 When Emacs is shutting down, perhaps because its connection to
13374 X has dropped, we should not look at them at all. */
13375 fr
= XFRAME (w
->frame
);
13376 sf
= SELECTED_FRAME ();
13378 if (!fr
->glyphs_initialized_p
)
13381 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
13382 if (popup_activated ())
13386 /* I don't think this happens but let's be paranoid. */
13387 if (redisplaying_p
)
13390 /* Record a function that clears redisplaying_p
13391 when we leave this function. */
13392 count
= SPECPDL_INDEX ();
13393 record_unwind_protect_void (unwind_redisplay
);
13394 redisplaying_p
= 1;
13395 specbind (Qinhibit_free_realized_faces
, Qnil
);
13397 /* Record this function, so it appears on the profiler's backtraces. */
13398 record_in_backtrace (Qredisplay_internal
, &Qnil
, 0);
13400 FOR_EACH_FRAME (tail
, frame
)
13401 XFRAME (frame
)->already_hscrolled_p
= 0;
13404 /* Remember the currently selected window. */
13408 last_escape_glyph_frame
= NULL
;
13409 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
13410 last_glyphless_glyph_frame
= NULL
;
13411 last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
13413 /* If face_change_count is non-zero, init_iterator will free all
13414 realized faces, which includes the faces referenced from current
13415 matrices. So, we can't reuse current matrices in this case. */
13416 if (face_change_count
)
13417 windows_or_buffers_changed
= 47;
13419 if ((FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
13420 && FRAME_TTY (sf
)->previous_frame
!= sf
)
13422 /* Since frames on a single ASCII terminal share the same
13423 display area, displaying a different frame means redisplay
13424 the whole thing. */
13425 SET_FRAME_GARBAGED (sf
);
13427 set_tty_color_mode (FRAME_TTY (sf
), sf
);
13429 FRAME_TTY (sf
)->previous_frame
= sf
;
13432 /* Set the visible flags for all frames. Do this before checking for
13433 resized or garbaged frames; they want to know if their frames are
13434 visible. See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
13435 number_of_visible_frames
= 0;
13437 FOR_EACH_FRAME (tail
, frame
)
13439 struct frame
*f
= XFRAME (frame
);
13441 if (FRAME_VISIBLE_P (f
))
13443 ++number_of_visible_frames
;
13444 /* Adjust matrices for visible frames only. */
13445 if (f
->fonts_changed
)
13447 adjust_frame_glyphs (f
);
13448 f
->fonts_changed
= 0;
13450 /* If cursor type has been changed on the frame
13451 other than selected, consider all frames. */
13452 if (f
!= sf
&& f
->cursor_type_changed
)
13453 update_mode_lines
= 31;
13455 clear_desired_matrices (f
);
13458 /* Notice any pending interrupt request to change frame size. */
13459 do_pending_window_change (1);
13461 /* do_pending_window_change could change the selected_window due to
13462 frame resizing which makes the selected window too small. */
13463 if (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
)
13466 /* Clear frames marked as garbaged. */
13467 clear_garbaged_frames ();
13469 /* Build menubar and tool-bar items. */
13470 if (NILP (Vmemory_full
))
13471 prepare_menu_bars ();
13473 reconsider_clip_changes (w
);
13475 /* In most cases selected window displays current buffer. */
13476 match_p
= XBUFFER (w
->contents
) == current_buffer
;
13479 /* Detect case that we need to write or remove a star in the mode line. */
13480 if ((SAVE_MODIFF
< MODIFF
) != w
->last_had_star
)
13481 w
->update_mode_line
= 1;
13483 if (mode_line_update_needed (w
))
13484 w
->update_mode_line
= 1;
13487 /* Normally the message* functions will have already displayed and
13488 updated the echo area, but the frame may have been trashed, or
13489 the update may have been preempted, so display the echo area
13490 again here. Checking message_cleared_p captures the case that
13491 the echo area should be cleared. */
13492 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
13493 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
13494 || (message_cleared_p
13495 && minibuf_level
== 0
13496 /* If the mini-window is currently selected, this means the
13497 echo-area doesn't show through. */
13498 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
13500 int window_height_changed_p
= echo_area_display (0);
13502 if (message_cleared_p
)
13503 update_miniwindow_p
= true;
13507 /* If we don't display the current message, don't clear the
13508 message_cleared_p flag, because, if we did, we wouldn't clear
13509 the echo area in the next redisplay which doesn't preserve
13511 if (!display_last_displayed_message_p
)
13512 message_cleared_p
= 0;
13514 if (window_height_changed_p
)
13516 windows_or_buffers_changed
= 50;
13518 /* If window configuration was changed, frames may have been
13519 marked garbaged. Clear them or we will experience
13520 surprises wrt scrolling. */
13521 clear_garbaged_frames ();
13524 else if (EQ (selected_window
, minibuf_window
)
13525 && (current_buffer
->clip_changed
|| window_outdated (w
))
13526 && resize_mini_window (w
, 0))
13528 /* Resized active mini-window to fit the size of what it is
13529 showing if its contents might have changed. */
13532 /* If window configuration was changed, frames may have been
13533 marked garbaged. Clear them or we will experience
13534 surprises wrt scrolling. */
13535 clear_garbaged_frames ();
13538 if (windows_or_buffers_changed
&& !update_mode_lines
)
13539 /* Code that sets windows_or_buffers_changed doesn't distinguish whether
13540 only the windows's contents needs to be refreshed, or whether the
13541 mode-lines also need a refresh. */
13542 update_mode_lines
= (windows_or_buffers_changed
== REDISPLAY_SOME
13543 ? REDISPLAY_SOME
: 32);
13545 /* If specs for an arrow have changed, do thorough redisplay
13546 to ensure we remove any arrow that should no longer exist. */
13547 if (overlay_arrows_changed_p ())
13548 /* Apparently, this is the only case where we update other windows,
13549 without updating other mode-lines. */
13550 windows_or_buffers_changed
= 49;
13552 consider_all_windows_p
= (update_mode_lines
13553 || windows_or_buffers_changed
);
13555 #define AINC(a,i) \
13556 if (VECTORP (a) && i >= 0 && i < ASIZE (a) && INTEGERP (AREF (a, i))) \
13557 ASET (a, i, make_number (1 + XINT (AREF (a, i))))
13559 AINC (Vredisplay__all_windows_cause
, windows_or_buffers_changed
);
13560 AINC (Vredisplay__mode_lines_cause
, update_mode_lines
);
13562 /* Optimize the case that only the line containing the cursor in the
13563 selected window has changed. Variables starting with this_ are
13564 set in display_line and record information about the line
13565 containing the cursor. */
13566 tlbufpos
= this_line_start_pos
;
13567 tlendpos
= this_line_end_pos
;
13568 if (!consider_all_windows_p
13569 && CHARPOS (tlbufpos
) > 0
13570 && !w
->update_mode_line
13571 && !current_buffer
->clip_changed
13572 && !current_buffer
->prevent_redisplay_optimizations_p
13573 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
13574 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
13575 && !XFRAME (w
->frame
)->cursor_type_changed
13576 /* Make sure recorded data applies to current buffer, etc. */
13577 && this_line_buffer
== current_buffer
13580 && !w
->optional_new_start
13581 /* Point must be on the line that we have info recorded about. */
13582 && PT
>= CHARPOS (tlbufpos
)
13583 && PT
<= Z
- CHARPOS (tlendpos
)
13584 /* All text outside that line, including its final newline,
13585 must be unchanged. */
13586 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
13587 CHARPOS (tlendpos
)))
13589 if (CHARPOS (tlbufpos
) > BEGV
13590 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
13591 && (CHARPOS (tlbufpos
) == ZV
13592 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
13593 /* Former continuation line has disappeared by becoming empty. */
13595 else if (window_outdated (w
) || MINI_WINDOW_P (w
))
13597 /* We have to handle the case of continuation around a
13598 wide-column character (see the comment in indent.c around
13601 For instance, in the following case:
13603 -------- Insert --------
13604 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
13605 J_I_ ==> J_I_ `^^' are cursors.
13609 As we have to redraw the line above, we cannot use this
13613 int line_height_before
= this_line_pixel_height
;
13615 /* Note that start_display will handle the case that the
13616 line starting at tlbufpos is a continuation line. */
13617 start_display (&it
, w
, tlbufpos
);
13619 /* Implementation note: It this still necessary? */
13620 if (it
.current_x
!= this_line_start_x
)
13623 TRACE ((stderr
, "trying display optimization 1\n"));
13624 w
->cursor
.vpos
= -1;
13625 overlay_arrow_seen
= 0;
13626 it
.vpos
= this_line_vpos
;
13627 it
.current_y
= this_line_y
;
13628 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
13629 display_line (&it
);
13631 /* If line contains point, is not continued,
13632 and ends at same distance from eob as before, we win. */
13633 if (w
->cursor
.vpos
>= 0
13634 /* Line is not continued, otherwise this_line_start_pos
13635 would have been set to 0 in display_line. */
13636 && CHARPOS (this_line_start_pos
)
13637 /* Line ends as before. */
13638 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
13639 /* Line has same height as before. Otherwise other lines
13640 would have to be shifted up or down. */
13641 && this_line_pixel_height
== line_height_before
)
13643 /* If this is not the window's last line, we must adjust
13644 the charstarts of the lines below. */
13645 if (it
.current_y
< it
.last_visible_y
)
13647 struct glyph_row
*row
13648 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
13649 ptrdiff_t delta
, delta_bytes
;
13651 /* We used to distinguish between two cases here,
13652 conditioned by Z - CHARPOS (tlendpos) == ZV, for
13653 when the line ends in a newline or the end of the
13654 buffer's accessible portion. But both cases did
13655 the same, so they were collapsed. */
13657 - CHARPOS (tlendpos
)
13658 - MATRIX_ROW_START_CHARPOS (row
));
13659 delta_bytes
= (Z_BYTE
13660 - BYTEPOS (tlendpos
)
13661 - MATRIX_ROW_START_BYTEPOS (row
));
13663 increment_matrix_positions (w
->current_matrix
,
13664 this_line_vpos
+ 1,
13665 w
->current_matrix
->nrows
,
13666 delta
, delta_bytes
);
13669 /* If this row displays text now but previously didn't,
13670 or vice versa, w->window_end_vpos may have to be
13672 if (MATRIX_ROW_DISPLAYS_TEXT_P (it
.glyph_row
- 1))
13674 if (w
->window_end_vpos
< this_line_vpos
)
13675 w
->window_end_vpos
= this_line_vpos
;
13677 else if (w
->window_end_vpos
== this_line_vpos
13678 && this_line_vpos
> 0)
13679 w
->window_end_vpos
= this_line_vpos
- 1;
13680 w
->window_end_valid
= 0;
13682 /* Update hint: No need to try to scroll in update_window. */
13683 w
->desired_matrix
->no_scrolling_p
= 1;
13686 *w
->desired_matrix
->method
= 0;
13687 debug_method_add (w
, "optimization 1");
13689 #ifdef HAVE_WINDOW_SYSTEM
13690 update_window_fringes (w
, 0);
13697 else if (/* Cursor position hasn't changed. */
13698 PT
== w
->last_point
13699 /* Make sure the cursor was last displayed
13700 in this window. Otherwise we have to reposition it. */
13702 /* PXW: Must be converted to pixels, probably. */
13703 && 0 <= w
->cursor
.vpos
13704 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
13708 do_pending_window_change (1);
13709 /* If selected_window changed, redisplay again. */
13710 if (WINDOWP (selected_window
)
13711 && (w
= XWINDOW (selected_window
)) != sw
)
13714 /* We used to always goto end_of_redisplay here, but this
13715 isn't enough if we have a blinking cursor. */
13716 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
13717 goto end_of_redisplay
;
13721 /* If highlighting the region, or if the cursor is in the echo area,
13722 then we can't just move the cursor. */
13723 else if (NILP (Vshow_trailing_whitespace
)
13724 && !cursor_in_echo_area
)
13727 struct glyph_row
*row
;
13729 /* Skip from tlbufpos to PT and see where it is. Note that
13730 PT may be in invisible text. If so, we will end at the
13731 next visible position. */
13732 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
13733 NULL
, DEFAULT_FACE_ID
);
13734 it
.current_x
= this_line_start_x
;
13735 it
.current_y
= this_line_y
;
13736 it
.vpos
= this_line_vpos
;
13738 /* The call to move_it_to stops in front of PT, but
13739 moves over before-strings. */
13740 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
13742 if (it
.vpos
== this_line_vpos
13743 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
13746 eassert (this_line_vpos
== it
.vpos
);
13747 eassert (this_line_y
== it
.current_y
);
13748 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
13750 *w
->desired_matrix
->method
= 0;
13751 debug_method_add (w
, "optimization 3");
13760 /* Text changed drastically or point moved off of line. */
13761 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, false);
13764 CHARPOS (this_line_start_pos
) = 0;
13765 ++clear_face_cache_count
;
13766 #ifdef HAVE_WINDOW_SYSTEM
13767 ++clear_image_cache_count
;
13770 /* Build desired matrices, and update the display. If
13771 consider_all_windows_p is non-zero, do it for all windows on all
13772 frames. Otherwise do it for selected_window, only. */
13774 if (consider_all_windows_p
)
13776 FOR_EACH_FRAME (tail
, frame
)
13777 XFRAME (frame
)->updated_p
= 0;
13779 propagate_buffer_redisplay ();
13781 FOR_EACH_FRAME (tail
, frame
)
13783 struct frame
*f
= XFRAME (frame
);
13785 /* We don't have to do anything for unselected terminal
13787 if ((FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
13788 && !EQ (FRAME_TTY (f
)->top_frame
, frame
))
13793 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
13796 /* Only GC scrollbars when we redisplay the whole frame. */
13797 = f
->redisplay
|| !REDISPLAY_SOME_P ();
13798 /* Mark all the scroll bars to be removed; we'll redeem
13799 the ones we want when we redisplay their windows. */
13800 if (gcscrollbars
&& FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
13801 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
13803 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13804 redisplay_windows (FRAME_ROOT_WINDOW (f
));
13805 /* Remember that the invisible frames need to be redisplayed next
13806 time they're visible. */
13807 else if (!REDISPLAY_SOME_P ())
13808 f
->redisplay
= true;
13810 /* The X error handler may have deleted that frame. */
13811 if (!FRAME_LIVE_P (f
))
13814 /* Any scroll bars which redisplay_windows should have
13815 nuked should now go away. */
13816 if (gcscrollbars
&& FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
13817 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
13819 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13821 /* If fonts changed on visible frame, display again. */
13822 if (f
->fonts_changed
)
13824 adjust_frame_glyphs (f
);
13825 f
->fonts_changed
= 0;
13829 /* See if we have to hscroll. */
13830 if (!f
->already_hscrolled_p
)
13832 f
->already_hscrolled_p
= 1;
13833 if (hscroll_windows (f
->root_window
))
13837 /* Prevent various kinds of signals during display
13838 update. stdio is not robust about handling
13839 signals, which can cause an apparent I/O error. */
13840 if (interrupt_input
)
13841 unrequest_sigio ();
13844 pending
|= update_frame (f
, 0, 0);
13845 f
->cursor_type_changed
= 0;
13851 eassert (EQ (XFRAME (selected_frame
)->selected_window
, selected_window
));
13855 /* Do the mark_window_display_accurate after all windows have
13856 been redisplayed because this call resets flags in buffers
13857 which are needed for proper redisplay. */
13858 FOR_EACH_FRAME (tail
, frame
)
13860 struct frame
*f
= XFRAME (frame
);
13863 f
->redisplay
= false;
13864 mark_window_display_accurate (f
->root_window
, 1);
13865 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
13866 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
13871 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13873 Lisp_Object mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13874 struct frame
*mini_frame
;
13876 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->contents
);
13877 /* Use list_of_error, not Qerror, so that
13878 we catch only errors and don't run the debugger. */
13879 internal_condition_case_1 (redisplay_window_1
, selected_window
,
13881 redisplay_window_error
);
13882 if (update_miniwindow_p
)
13883 internal_condition_case_1 (redisplay_window_1
, mini_window
,
13885 redisplay_window_error
);
13887 /* Compare desired and current matrices, perform output. */
13890 /* If fonts changed, display again. */
13891 if (sf
->fonts_changed
)
13894 /* Prevent various kinds of signals during display update.
13895 stdio is not robust about handling signals,
13896 which can cause an apparent I/O error. */
13897 if (interrupt_input
)
13898 unrequest_sigio ();
13901 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13903 if (hscroll_windows (selected_window
))
13906 XWINDOW (selected_window
)->must_be_updated_p
= true;
13907 pending
= update_frame (sf
, 0, 0);
13908 sf
->cursor_type_changed
= 0;
13911 /* We may have called echo_area_display at the top of this
13912 function. If the echo area is on another frame, that may
13913 have put text on a frame other than the selected one, so the
13914 above call to update_frame would not have caught it. Catch
13916 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13917 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
13919 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
13921 XWINDOW (mini_window
)->must_be_updated_p
= true;
13922 pending
|= update_frame (mini_frame
, 0, 0);
13923 mini_frame
->cursor_type_changed
= 0;
13924 if (!pending
&& hscroll_windows (mini_window
))
13929 /* If display was paused because of pending input, make sure we do a
13930 thorough update the next time. */
13933 /* Prevent the optimization at the beginning of
13934 redisplay_internal that tries a single-line update of the
13935 line containing the cursor in the selected window. */
13936 CHARPOS (this_line_start_pos
) = 0;
13938 /* Let the overlay arrow be updated the next time. */
13939 update_overlay_arrows (0);
13941 /* If we pause after scrolling, some rows in the current
13942 matrices of some windows are not valid. */
13943 if (!WINDOW_FULL_WIDTH_P (w
)
13944 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
13945 update_mode_lines
= 36;
13949 if (!consider_all_windows_p
)
13951 /* This has already been done above if
13952 consider_all_windows_p is set. */
13953 if (XBUFFER (w
->contents
)->text
->redisplay
13954 && buffer_window_count (XBUFFER (w
->contents
)) > 1)
13955 /* This can happen if b->text->redisplay was set during
13957 propagate_buffer_redisplay ();
13958 mark_window_display_accurate_1 (w
, 1);
13960 /* Say overlay arrows are up to date. */
13961 update_overlay_arrows (1);
13963 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
13964 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
13967 update_mode_lines
= 0;
13968 windows_or_buffers_changed
= 0;
13971 /* Start SIGIO interrupts coming again. Having them off during the
13972 code above makes it less likely one will discard output, but not
13973 impossible, since there might be stuff in the system buffer here.
13974 But it is much hairier to try to do anything about that. */
13975 if (interrupt_input
)
13979 /* If a frame has become visible which was not before, redisplay
13980 again, so that we display it. Expose events for such a frame
13981 (which it gets when becoming visible) don't call the parts of
13982 redisplay constructing glyphs, so simply exposing a frame won't
13983 display anything in this case. So, we have to display these
13984 frames here explicitly. */
13989 FOR_EACH_FRAME (tail
, frame
)
13991 if (XFRAME (frame
)->visible
)
13995 if (new_count
!= number_of_visible_frames
)
13996 windows_or_buffers_changed
= 52;
13999 /* Change frame size now if a change is pending. */
14000 do_pending_window_change (1);
14002 /* If we just did a pending size change, or have additional
14003 visible frames, or selected_window changed, redisplay again. */
14004 if ((windows_or_buffers_changed
&& !pending
)
14005 || (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
))
14008 /* Clear the face and image caches.
14010 We used to do this only if consider_all_windows_p. But the cache
14011 needs to be cleared if a timer creates images in the current
14012 buffer (e.g. the test case in Bug#6230). */
14014 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
14016 clear_face_cache (0);
14017 clear_face_cache_count
= 0;
14020 #ifdef HAVE_WINDOW_SYSTEM
14021 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
14023 clear_image_caches (Qnil
);
14024 clear_image_cache_count
= 0;
14026 #endif /* HAVE_WINDOW_SYSTEM */
14029 if (interrupt_input
&& interrupts_deferred
)
14032 unbind_to (count
, Qnil
);
14037 /* Redisplay, but leave alone any recent echo area message unless
14038 another message has been requested in its place.
14040 This is useful in situations where you need to redisplay but no
14041 user action has occurred, making it inappropriate for the message
14042 area to be cleared. See tracking_off and
14043 wait_reading_process_output for examples of these situations.
14045 FROM_WHERE is an integer saying from where this function was
14046 called. This is useful for debugging. */
14049 redisplay_preserve_echo_area (int from_where
)
14051 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
14053 if (!NILP (echo_area_buffer
[1]))
14055 /* We have a previously displayed message, but no current
14056 message. Redisplay the previous message. */
14057 display_last_displayed_message_p
= 1;
14058 redisplay_internal ();
14059 display_last_displayed_message_p
= 0;
14062 redisplay_internal ();
14064 flush_frame (SELECTED_FRAME ());
14068 /* Function registered with record_unwind_protect in redisplay_internal. */
14071 unwind_redisplay (void)
14073 redisplaying_p
= 0;
14077 /* Mark the display of leaf window W as accurate or inaccurate.
14078 If ACCURATE_P is non-zero mark display of W as accurate. If
14079 ACCURATE_P is zero, arrange for W to be redisplayed the next
14080 time redisplay_internal is called. */
14083 mark_window_display_accurate_1 (struct window
*w
, int accurate_p
)
14085 struct buffer
*b
= XBUFFER (w
->contents
);
14087 w
->last_modified
= accurate_p
? BUF_MODIFF (b
) : 0;
14088 w
->last_overlay_modified
= accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0;
14089 w
->last_had_star
= BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
);
14093 b
->clip_changed
= false;
14094 b
->prevent_redisplay_optimizations_p
= false;
14095 eassert (buffer_window_count (b
) > 0);
14096 /* Resetting b->text->redisplay is problematic!
14097 In order to make it safer to do it here, redisplay_internal must
14098 have copied all b->text->redisplay to their respective windows. */
14099 b
->text
->redisplay
= false;
14101 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
14102 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
14103 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
14104 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
14106 w
->current_matrix
->buffer
= b
;
14107 w
->current_matrix
->begv
= BUF_BEGV (b
);
14108 w
->current_matrix
->zv
= BUF_ZV (b
);
14110 w
->last_cursor_vpos
= w
->cursor
.vpos
;
14111 w
->last_cursor_off_p
= w
->cursor_off_p
;
14113 if (w
== XWINDOW (selected_window
))
14114 w
->last_point
= BUF_PT (b
);
14116 w
->last_point
= marker_position (w
->pointm
);
14118 w
->window_end_valid
= true;
14119 w
->update_mode_line
= false;
14122 w
->redisplay
= !accurate_p
;
14126 /* Mark the display of windows in the window tree rooted at WINDOW as
14127 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
14128 windows as accurate. If ACCURATE_P is zero, arrange for windows to
14129 be redisplayed the next time redisplay_internal is called. */
14132 mark_window_display_accurate (Lisp_Object window
, int accurate_p
)
14136 for (; !NILP (window
); window
= w
->next
)
14138 w
= XWINDOW (window
);
14139 if (WINDOWP (w
->contents
))
14140 mark_window_display_accurate (w
->contents
, accurate_p
);
14142 mark_window_display_accurate_1 (w
, accurate_p
);
14146 update_overlay_arrows (1);
14148 /* Force a thorough redisplay the next time by setting
14149 last_arrow_position and last_arrow_string to t, which is
14150 unequal to any useful value of Voverlay_arrow_... */
14151 update_overlay_arrows (-1);
14155 /* Return value in display table DP (Lisp_Char_Table *) for character
14156 C. Since a display table doesn't have any parent, we don't have to
14157 follow parent. Do not call this function directly but use the
14158 macro DISP_CHAR_VECTOR. */
14161 disp_char_vector (struct Lisp_Char_Table
*dp
, int c
)
14165 if (ASCII_CHAR_P (c
))
14168 if (SUB_CHAR_TABLE_P (val
))
14169 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
14175 XSETCHAR_TABLE (table
, dp
);
14176 val
= char_table_ref (table
, c
);
14185 /***********************************************************************
14187 ***********************************************************************/
14189 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
14192 redisplay_windows (Lisp_Object window
)
14194 while (!NILP (window
))
14196 struct window
*w
= XWINDOW (window
);
14198 if (WINDOWP (w
->contents
))
14199 redisplay_windows (w
->contents
);
14200 else if (BUFFERP (w
->contents
))
14202 displayed_buffer
= XBUFFER (w
->contents
);
14203 /* Use list_of_error, not Qerror, so that
14204 we catch only errors and don't run the debugger. */
14205 internal_condition_case_1 (redisplay_window_0
, window
,
14207 redisplay_window_error
);
14215 redisplay_window_error (Lisp_Object ignore
)
14217 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
14222 redisplay_window_0 (Lisp_Object window
)
14224 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
14225 redisplay_window (window
, false);
14230 redisplay_window_1 (Lisp_Object window
)
14232 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
14233 redisplay_window (window
, true);
14238 /* Set cursor position of W. PT is assumed to be displayed in ROW.
14239 DELTA and DELTA_BYTES are the numbers of characters and bytes by
14240 which positions recorded in ROW differ from current buffer
14243 Return 0 if cursor is not on this row, 1 otherwise. */
14246 set_cursor_from_row (struct window
*w
, struct glyph_row
*row
,
14247 struct glyph_matrix
*matrix
,
14248 ptrdiff_t delta
, ptrdiff_t delta_bytes
,
14251 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
14252 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
14253 struct glyph
*cursor
= NULL
;
14254 /* The last known character position in row. */
14255 ptrdiff_t last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
14257 ptrdiff_t pt_old
= PT
- delta
;
14258 ptrdiff_t pos_before
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
14259 ptrdiff_t pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
14260 struct glyph
*glyph_before
= glyph
- 1, *glyph_after
= end
;
14261 /* A glyph beyond the edge of TEXT_AREA which we should never
14263 struct glyph
*glyphs_end
= end
;
14264 /* Non-zero means we've found a match for cursor position, but that
14265 glyph has the avoid_cursor_p flag set. */
14266 int match_with_avoid_cursor
= 0;
14267 /* Non-zero means we've seen at least one glyph that came from a
14269 int string_seen
= 0;
14270 /* Largest and smallest buffer positions seen so far during scan of
14272 ptrdiff_t bpos_max
= pos_before
;
14273 ptrdiff_t bpos_min
= pos_after
;
14274 /* Last buffer position covered by an overlay string with an integer
14275 `cursor' property. */
14276 ptrdiff_t bpos_covered
= 0;
14277 /* Non-zero means the display string on which to display the cursor
14278 comes from a text property, not from an overlay. */
14279 int string_from_text_prop
= 0;
14281 /* Don't even try doing anything if called for a mode-line or
14282 header-line row, since the rest of the code isn't prepared to
14283 deal with such calamities. */
14284 eassert (!row
->mode_line_p
);
14285 if (row
->mode_line_p
)
14288 /* Skip over glyphs not having an object at the start and the end of
14289 the row. These are special glyphs like truncation marks on
14290 terminal frames. */
14291 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14293 if (!row
->reversed_p
)
14296 && INTEGERP (glyph
->object
)
14297 && glyph
->charpos
< 0)
14299 x
+= glyph
->pixel_width
;
14303 && INTEGERP ((end
- 1)->object
)
14304 /* CHARPOS is zero for blanks and stretch glyphs
14305 inserted by extend_face_to_end_of_line. */
14306 && (end
- 1)->charpos
<= 0)
14308 glyph_before
= glyph
- 1;
14315 /* If the glyph row is reversed, we need to process it from back
14316 to front, so swap the edge pointers. */
14317 glyphs_end
= end
= glyph
- 1;
14318 glyph
+= row
->used
[TEXT_AREA
] - 1;
14320 while (glyph
> end
+ 1
14321 && INTEGERP (glyph
->object
)
14322 && glyph
->charpos
< 0)
14325 x
-= glyph
->pixel_width
;
14327 if (INTEGERP (glyph
->object
) && glyph
->charpos
< 0)
14329 /* By default, in reversed rows we put the cursor on the
14330 rightmost (first in the reading order) glyph. */
14331 for (g
= end
+ 1; g
< glyph
; g
++)
14332 x
+= g
->pixel_width
;
14334 && INTEGERP ((end
+ 1)->object
)
14335 && (end
+ 1)->charpos
<= 0)
14337 glyph_before
= glyph
+ 1;
14341 else if (row
->reversed_p
)
14343 /* In R2L rows that don't display text, put the cursor on the
14344 rightmost glyph. Case in point: an empty last line that is
14345 part of an R2L paragraph. */
14347 /* Avoid placing the cursor on the last glyph of the row, where
14348 on terminal frames we hold the vertical border between
14349 adjacent windows. */
14350 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w
))
14351 && !WINDOW_RIGHTMOST_P (w
)
14352 && cursor
== row
->glyphs
[LAST_AREA
] - 1)
14354 x
= -1; /* will be computed below, at label compute_x */
14357 /* Step 1: Try to find the glyph whose character position
14358 corresponds to point. If that's not possible, find 2 glyphs
14359 whose character positions are the closest to point, one before
14360 point, the other after it. */
14361 if (!row
->reversed_p
)
14362 while (/* not marched to end of glyph row */
14364 /* glyph was not inserted by redisplay for internal purposes */
14365 && !INTEGERP (glyph
->object
))
14367 if (BUFFERP (glyph
->object
))
14369 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14371 if (glyph
->charpos
> bpos_max
)
14372 bpos_max
= glyph
->charpos
;
14373 if (glyph
->charpos
< bpos_min
)
14374 bpos_min
= glyph
->charpos
;
14375 if (!glyph
->avoid_cursor_p
)
14377 /* If we hit point, we've found the glyph on which to
14378 display the cursor. */
14381 match_with_avoid_cursor
= 0;
14384 /* See if we've found a better approximation to
14385 POS_BEFORE or to POS_AFTER. */
14386 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14388 pos_before
= glyph
->charpos
;
14389 glyph_before
= glyph
;
14391 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14393 pos_after
= glyph
->charpos
;
14394 glyph_after
= glyph
;
14397 else if (dpos
== 0)
14398 match_with_avoid_cursor
= 1;
14400 else if (STRINGP (glyph
->object
))
14402 Lisp_Object chprop
;
14403 ptrdiff_t glyph_pos
= glyph
->charpos
;
14405 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14407 if (!NILP (chprop
))
14409 /* If the string came from a `display' text property,
14410 look up the buffer position of that property and
14411 use that position to update bpos_max, as if we
14412 actually saw such a position in one of the row's
14413 glyphs. This helps with supporting integer values
14414 of `cursor' property on the display string in
14415 situations where most or all of the row's buffer
14416 text is completely covered by display properties,
14417 so that no glyph with valid buffer positions is
14418 ever seen in the row. */
14419 ptrdiff_t prop_pos
=
14420 string_buffer_position_lim (glyph
->object
, pos_before
,
14423 if (prop_pos
>= pos_before
)
14424 bpos_max
= prop_pos
;
14426 if (INTEGERP (chprop
))
14428 bpos_covered
= bpos_max
+ XINT (chprop
);
14429 /* If the `cursor' property covers buffer positions up
14430 to and including point, we should display cursor on
14431 this glyph. Note that, if a `cursor' property on one
14432 of the string's characters has an integer value, we
14433 will break out of the loop below _before_ we get to
14434 the position match above. IOW, integer values of
14435 the `cursor' property override the "exact match for
14436 point" strategy of positioning the cursor. */
14437 /* Implementation note: bpos_max == pt_old when, e.g.,
14438 we are in an empty line, where bpos_max is set to
14439 MATRIX_ROW_START_CHARPOS, see above. */
14440 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14449 x
+= glyph
->pixel_width
;
14452 else if (glyph
> end
) /* row is reversed */
14453 while (!INTEGERP (glyph
->object
))
14455 if (BUFFERP (glyph
->object
))
14457 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14459 if (glyph
->charpos
> bpos_max
)
14460 bpos_max
= glyph
->charpos
;
14461 if (glyph
->charpos
< bpos_min
)
14462 bpos_min
= glyph
->charpos
;
14463 if (!glyph
->avoid_cursor_p
)
14467 match_with_avoid_cursor
= 0;
14470 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14472 pos_before
= glyph
->charpos
;
14473 glyph_before
= glyph
;
14475 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14477 pos_after
= glyph
->charpos
;
14478 glyph_after
= glyph
;
14481 else if (dpos
== 0)
14482 match_with_avoid_cursor
= 1;
14484 else if (STRINGP (glyph
->object
))
14486 Lisp_Object chprop
;
14487 ptrdiff_t glyph_pos
= glyph
->charpos
;
14489 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14491 if (!NILP (chprop
))
14493 ptrdiff_t prop_pos
=
14494 string_buffer_position_lim (glyph
->object
, pos_before
,
14497 if (prop_pos
>= pos_before
)
14498 bpos_max
= prop_pos
;
14500 if (INTEGERP (chprop
))
14502 bpos_covered
= bpos_max
+ XINT (chprop
);
14503 /* If the `cursor' property covers buffer positions up
14504 to and including point, we should display cursor on
14506 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14515 if (glyph
== glyphs_end
) /* don't dereference outside TEXT_AREA */
14517 x
--; /* can't use any pixel_width */
14520 x
-= glyph
->pixel_width
;
14523 /* Step 2: If we didn't find an exact match for point, we need to
14524 look for a proper place to put the cursor among glyphs between
14525 GLYPH_BEFORE and GLYPH_AFTER. */
14526 if (!((row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14527 && BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14528 && !(bpos_max
<= pt_old
&& pt_old
<= bpos_covered
))
14530 /* An empty line has a single glyph whose OBJECT is zero and
14531 whose CHARPOS is the position of a newline on that line.
14532 Note that on a TTY, there are more glyphs after that, which
14533 were produced by extend_face_to_end_of_line, but their
14534 CHARPOS is zero or negative. */
14536 (row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14537 && INTEGERP (glyph
->object
) && glyph
->charpos
> 0
14538 /* On a TTY, continued and truncated rows also have a glyph at
14539 their end whose OBJECT is zero and whose CHARPOS is
14540 positive (the continuation and truncation glyphs), but such
14541 rows are obviously not "empty". */
14542 && !(row
->continued_p
|| row
->truncated_on_right_p
);
14544 if (row
->ends_in_ellipsis_p
&& pos_after
== last_pos
)
14546 ptrdiff_t ellipsis_pos
;
14548 /* Scan back over the ellipsis glyphs. */
14549 if (!row
->reversed_p
)
14551 ellipsis_pos
= (glyph
- 1)->charpos
;
14552 while (glyph
> row
->glyphs
[TEXT_AREA
]
14553 && (glyph
- 1)->charpos
== ellipsis_pos
)
14554 glyph
--, x
-= glyph
->pixel_width
;
14555 /* That loop always goes one position too far, including
14556 the glyph before the ellipsis. So scan forward over
14558 x
+= glyph
->pixel_width
;
14561 else /* row is reversed */
14563 ellipsis_pos
= (glyph
+ 1)->charpos
;
14564 while (glyph
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14565 && (glyph
+ 1)->charpos
== ellipsis_pos
)
14566 glyph
++, x
+= glyph
->pixel_width
;
14567 x
-= glyph
->pixel_width
;
14571 else if (match_with_avoid_cursor
)
14573 cursor
= glyph_after
;
14576 else if (string_seen
)
14578 int incr
= row
->reversed_p
? -1 : +1;
14580 /* Need to find the glyph that came out of a string which is
14581 present at point. That glyph is somewhere between
14582 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
14583 positioned between POS_BEFORE and POS_AFTER in the
14585 struct glyph
*start
, *stop
;
14586 ptrdiff_t pos
= pos_before
;
14590 /* If the row ends in a newline from a display string,
14591 reordering could have moved the glyphs belonging to the
14592 string out of the [GLYPH_BEFORE..GLYPH_AFTER] range. So
14593 in this case we extend the search to the last glyph in
14594 the row that was not inserted by redisplay. */
14595 if (row
->ends_in_newline_from_string_p
)
14598 pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
14601 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
14602 correspond to POS_BEFORE and POS_AFTER, respectively. We
14603 need START and STOP in the order that corresponds to the
14604 row's direction as given by its reversed_p flag. If the
14605 directionality of characters between POS_BEFORE and
14606 POS_AFTER is the opposite of the row's base direction,
14607 these characters will have been reordered for display,
14608 and we need to reverse START and STOP. */
14609 if (!row
->reversed_p
)
14611 start
= min (glyph_before
, glyph_after
);
14612 stop
= max (glyph_before
, glyph_after
);
14616 start
= max (glyph_before
, glyph_after
);
14617 stop
= min (glyph_before
, glyph_after
);
14619 for (glyph
= start
+ incr
;
14620 row
->reversed_p
? glyph
> stop
: glyph
< stop
; )
14623 /* Any glyphs that come from the buffer are here because
14624 of bidi reordering. Skip them, and only pay
14625 attention to glyphs that came from some string. */
14626 if (STRINGP (glyph
->object
))
14630 /* If the display property covers the newline, we
14631 need to search for it one position farther. */
14632 ptrdiff_t lim
= pos_after
14633 + (pos_after
== MATRIX_ROW_END_CHARPOS (row
) + delta
);
14635 string_from_text_prop
= 0;
14636 str
= glyph
->object
;
14637 tem
= string_buffer_position_lim (str
, pos
, lim
, 0);
14638 if (tem
== 0 /* from overlay */
14641 /* If the string from which this glyph came is
14642 found in the buffer at point, or at position
14643 that is closer to point than pos_after, then
14644 we've found the glyph we've been looking for.
14645 If it comes from an overlay (tem == 0), and
14646 it has the `cursor' property on one of its
14647 glyphs, record that glyph as a candidate for
14648 displaying the cursor. (As in the
14649 unidirectional version, we will display the
14650 cursor on the last candidate we find.) */
14653 || (tem
- pt_old
> 0 && tem
< pos_after
))
14655 /* The glyphs from this string could have
14656 been reordered. Find the one with the
14657 smallest string position. Or there could
14658 be a character in the string with the
14659 `cursor' property, which means display
14660 cursor on that character's glyph. */
14661 ptrdiff_t strpos
= glyph
->charpos
;
14666 string_from_text_prop
= 1;
14669 (row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14670 && EQ (glyph
->object
, str
);
14674 ptrdiff_t gpos
= glyph
->charpos
;
14676 cprop
= Fget_char_property (make_number (gpos
),
14684 if (tem
&& glyph
->charpos
< strpos
)
14686 strpos
= glyph
->charpos
;
14692 || (tem
- pt_old
> 0 && tem
< pos_after
))
14696 pos
= tem
+ 1; /* don't find previous instances */
14698 /* This string is not what we want; skip all of the
14699 glyphs that came from it. */
14700 while ((row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14701 && EQ (glyph
->object
, str
))
14708 /* If we reached the end of the line, and END was from a string,
14709 the cursor is not on this line. */
14711 && (row
->reversed_p
? glyph
<= end
: glyph
>= end
)
14712 && (row
->reversed_p
? end
> glyphs_end
: end
< glyphs_end
)
14713 && STRINGP (end
->object
)
14714 && row
->continued_p
)
14717 /* A truncated row may not include PT among its character positions.
14718 Setting the cursor inside the scroll margin will trigger
14719 recalculation of hscroll in hscroll_window_tree. But if a
14720 display string covers point, defer to the string-handling
14721 code below to figure this out. */
14722 else if (row
->truncated_on_left_p
&& pt_old
< bpos_min
)
14724 cursor
= glyph_before
;
14727 else if ((row
->truncated_on_right_p
&& pt_old
> bpos_max
)
14728 /* Zero-width characters produce no glyphs. */
14730 && (row
->reversed_p
14731 ? glyph_after
> glyphs_end
14732 : glyph_after
< glyphs_end
)))
14734 cursor
= glyph_after
;
14740 if (cursor
!= NULL
)
14742 else if (glyph
== glyphs_end
14743 && pos_before
== pos_after
14744 && STRINGP ((row
->reversed_p
14745 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14746 : row
->glyphs
[TEXT_AREA
])->object
))
14748 /* If all the glyphs of this row came from strings, put the
14749 cursor on the first glyph of the row. This avoids having the
14750 cursor outside of the text area in this very rare and hard
14754 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14755 : row
->glyphs
[TEXT_AREA
];
14761 /* Need to compute x that corresponds to GLYPH. */
14762 for (g
= row
->glyphs
[TEXT_AREA
], x
= row
->x
; g
< glyph
; g
++)
14764 if (g
>= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
])
14766 x
+= g
->pixel_width
;
14770 /* ROW could be part of a continued line, which, under bidi
14771 reordering, might have other rows whose start and end charpos
14772 occlude point. Only set w->cursor if we found a better
14773 approximation to the cursor position than we have from previously
14774 examined candidate rows belonging to the same continued line. */
14775 if (/* We already have a candidate row. */
14776 w
->cursor
.vpos
>= 0
14777 /* That candidate is not the row we are processing. */
14778 && MATRIX_ROW (matrix
, w
->cursor
.vpos
) != row
14779 /* Make sure cursor.vpos specifies a row whose start and end
14780 charpos occlude point, and it is valid candidate for being a
14781 cursor-row. This is because some callers of this function
14782 leave cursor.vpos at the row where the cursor was displayed
14783 during the last redisplay cycle. */
14784 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)) <= pt_old
14785 && pt_old
<= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14786 && cursor_row_p (MATRIX_ROW (matrix
, w
->cursor
.vpos
)))
14789 = MATRIX_ROW_GLYPH_START (matrix
, w
->cursor
.vpos
) + w
->cursor
.hpos
;
14791 /* Don't consider glyphs that are outside TEXT_AREA. */
14792 if (!(row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
))
14794 /* Keep the candidate whose buffer position is the closest to
14795 point or has the `cursor' property. */
14796 if (/* Previous candidate is a glyph in TEXT_AREA of that row. */
14797 w
->cursor
.hpos
>= 0
14798 && w
->cursor
.hpos
< MATRIX_ROW_USED (matrix
, w
->cursor
.vpos
)
14799 && ((BUFFERP (g1
->object
)
14800 && (g1
->charpos
== pt_old
/* An exact match always wins. */
14801 || (BUFFERP (glyph
->object
)
14802 && eabs (g1
->charpos
- pt_old
)
14803 < eabs (glyph
->charpos
- pt_old
))))
14804 /* Previous candidate is a glyph from a string that has
14805 a non-nil `cursor' property. */
14806 || (STRINGP (g1
->object
)
14807 && (!NILP (Fget_char_property (make_number (g1
->charpos
),
14808 Qcursor
, g1
->object
))
14809 /* Previous candidate is from the same display
14810 string as this one, and the display string
14811 came from a text property. */
14812 || (EQ (g1
->object
, glyph
->object
)
14813 && string_from_text_prop
)
14814 /* this candidate is from newline and its
14815 position is not an exact match */
14816 || (INTEGERP (glyph
->object
)
14817 && glyph
->charpos
!= pt_old
)))))
14819 /* If this candidate gives an exact match, use that. */
14820 if (!((BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14821 /* If this candidate is a glyph created for the
14822 terminating newline of a line, and point is on that
14823 newline, it wins because it's an exact match. */
14824 || (!row
->continued_p
14825 && INTEGERP (glyph
->object
)
14826 && glyph
->charpos
== 0
14827 && pt_old
== MATRIX_ROW_END_CHARPOS (row
) - 1))
14828 /* Otherwise, keep the candidate that comes from a row
14829 spanning less buffer positions. This may win when one or
14830 both candidate positions are on glyphs that came from
14831 display strings, for which we cannot compare buffer
14833 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14834 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14835 < MATRIX_ROW_END_CHARPOS (row
) - MATRIX_ROW_START_CHARPOS (row
))
14838 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
14840 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
14841 w
->cursor
.y
= row
->y
+ dy
;
14843 if (w
== XWINDOW (selected_window
))
14845 if (!row
->continued_p
14846 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
14849 this_line_buffer
= XBUFFER (w
->contents
);
14851 CHARPOS (this_line_start_pos
)
14852 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
14853 BYTEPOS (this_line_start_pos
)
14854 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
14856 CHARPOS (this_line_end_pos
)
14857 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
14858 BYTEPOS (this_line_end_pos
)
14859 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
14861 this_line_y
= w
->cursor
.y
;
14862 this_line_pixel_height
= row
->height
;
14863 this_line_vpos
= w
->cursor
.vpos
;
14864 this_line_start_x
= row
->x
;
14867 CHARPOS (this_line_start_pos
) = 0;
14874 /* Run window scroll functions, if any, for WINDOW with new window
14875 start STARTP. Sets the window start of WINDOW to that position.
14877 We assume that the window's buffer is really current. */
14879 static struct text_pos
14880 run_window_scroll_functions (Lisp_Object window
, struct text_pos startp
)
14882 struct window
*w
= XWINDOW (window
);
14883 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
14885 eassert (current_buffer
== XBUFFER (w
->contents
));
14887 if (!NILP (Vwindow_scroll_functions
))
14889 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
14890 make_number (CHARPOS (startp
)));
14891 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14892 /* In case the hook functions switch buffers. */
14893 set_buffer_internal (XBUFFER (w
->contents
));
14900 /* Make sure the line containing the cursor is fully visible.
14901 A value of 1 means there is nothing to be done.
14902 (Either the line is fully visible, or it cannot be made so,
14903 or we cannot tell.)
14905 If FORCE_P is non-zero, return 0 even if partial visible cursor row
14906 is higher than window.
14908 A value of 0 means the caller should do scrolling
14909 as if point had gone off the screen. */
14912 cursor_row_fully_visible_p (struct window
*w
, int force_p
, int current_matrix_p
)
14914 struct glyph_matrix
*matrix
;
14915 struct glyph_row
*row
;
14918 if (!make_cursor_line_fully_visible_p
)
14921 /* It's not always possible to find the cursor, e.g, when a window
14922 is full of overlay strings. Don't do anything in that case. */
14923 if (w
->cursor
.vpos
< 0)
14926 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
14927 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
14929 /* If the cursor row is not partially visible, there's nothing to do. */
14930 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
14933 /* If the row the cursor is in is taller than the window's height,
14934 it's not clear what to do, so do nothing. */
14935 window_height
= window_box_height (w
);
14936 if (row
->height
>= window_height
)
14938 if (!force_p
|| MINI_WINDOW_P (w
)
14939 || w
->vscroll
|| w
->cursor
.vpos
== 0)
14946 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
14947 non-zero means only WINDOW is redisplayed in redisplay_internal.
14948 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
14949 in redisplay_window to bring a partially visible line into view in
14950 the case that only the cursor has moved.
14952 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
14953 last screen line's vertical height extends past the end of the screen.
14957 1 if scrolling succeeded
14959 0 if scrolling didn't find point.
14961 -1 if new fonts have been loaded so that we must interrupt
14962 redisplay, adjust glyph matrices, and try again. */
14968 SCROLLING_NEED_LARGER_MATRICES
14971 /* If scroll-conservatively is more than this, never recenter.
14973 If you change this, don't forget to update the doc string of
14974 `scroll-conservatively' and the Emacs manual. */
14975 #define SCROLL_LIMIT 100
14978 try_scrolling (Lisp_Object window
, int just_this_one_p
,
14979 ptrdiff_t arg_scroll_conservatively
, ptrdiff_t scroll_step
,
14980 int temp_scroll_step
, int last_line_misfit
)
14982 struct window
*w
= XWINDOW (window
);
14983 struct frame
*f
= XFRAME (w
->frame
);
14984 struct text_pos pos
, startp
;
14986 int this_scroll_margin
, scroll_max
, rc
, height
;
14987 int dy
= 0, amount_to_scroll
= 0, scroll_down_p
= 0;
14988 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
14989 Lisp_Object aggressive
;
14990 /* We will never try scrolling more than this number of lines. */
14991 int scroll_limit
= SCROLL_LIMIT
;
14992 int frame_line_height
= default_line_pixel_height (w
);
14993 int window_total_lines
14994 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) / frame_line_height
;
14997 debug_method_add (w
, "try_scrolling");
15000 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15002 /* Compute scroll margin height in pixels. We scroll when point is
15003 within this distance from the top or bottom of the window. */
15004 if (scroll_margin
> 0)
15005 this_scroll_margin
= min (scroll_margin
, window_total_lines
/ 4)
15006 * frame_line_height
;
15008 this_scroll_margin
= 0;
15010 /* Force arg_scroll_conservatively to have a reasonable value, to
15011 avoid scrolling too far away with slow move_it_* functions. Note
15012 that the user can supply scroll-conservatively equal to
15013 `most-positive-fixnum', which can be larger than INT_MAX. */
15014 if (arg_scroll_conservatively
> scroll_limit
)
15016 arg_scroll_conservatively
= scroll_limit
+ 1;
15017 scroll_max
= scroll_limit
* frame_line_height
;
15019 else if (scroll_step
|| arg_scroll_conservatively
|| temp_scroll_step
)
15020 /* Compute how much we should try to scroll maximally to bring
15021 point into view. */
15022 scroll_max
= (max (scroll_step
,
15023 max (arg_scroll_conservatively
, temp_scroll_step
))
15024 * frame_line_height
);
15025 else if (NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
))
15026 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
)))
15027 /* We're trying to scroll because of aggressive scrolling but no
15028 scroll_step is set. Choose an arbitrary one. */
15029 scroll_max
= 10 * frame_line_height
;
15035 /* Decide whether to scroll down. */
15036 if (PT
> CHARPOS (startp
))
15038 int scroll_margin_y
;
15040 /* Compute the pixel ypos of the scroll margin, then move IT to
15041 either that ypos or PT, whichever comes first. */
15042 start_display (&it
, w
, startp
);
15043 scroll_margin_y
= it
.last_visible_y
- this_scroll_margin
15044 - frame_line_height
* extra_scroll_margin_lines
;
15045 move_it_to (&it
, PT
, -1, scroll_margin_y
- 1, -1,
15046 (MOVE_TO_POS
| MOVE_TO_Y
));
15048 if (PT
> CHARPOS (it
.current
.pos
))
15050 int y0
= line_bottom_y (&it
);
15051 /* Compute how many pixels below window bottom to stop searching
15052 for PT. This avoids costly search for PT that is far away if
15053 the user limited scrolling by a small number of lines, but
15054 always finds PT if scroll_conservatively is set to a large
15055 number, such as most-positive-fixnum. */
15056 int slack
= max (scroll_max
, 10 * frame_line_height
);
15057 int y_to_move
= it
.last_visible_y
+ slack
;
15059 /* Compute the distance from the scroll margin to PT or to
15060 the scroll limit, whichever comes first. This should
15061 include the height of the cursor line, to make that line
15063 move_it_to (&it
, PT
, -1, y_to_move
,
15064 -1, MOVE_TO_POS
| MOVE_TO_Y
);
15065 dy
= line_bottom_y (&it
) - y0
;
15067 if (dy
> scroll_max
)
15068 return SCROLLING_FAILED
;
15077 /* Point is in or below the bottom scroll margin, so move the
15078 window start down. If scrolling conservatively, move it just
15079 enough down to make point visible. If scroll_step is set,
15080 move it down by scroll_step. */
15081 if (arg_scroll_conservatively
)
15083 = min (max (dy
, frame_line_height
),
15084 frame_line_height
* arg_scroll_conservatively
);
15085 else if (scroll_step
|| temp_scroll_step
)
15086 amount_to_scroll
= scroll_max
;
15089 aggressive
= BVAR (current_buffer
, scroll_up_aggressively
);
15090 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
15091 if (NUMBERP (aggressive
))
15093 double float_amount
= XFLOATINT (aggressive
) * height
;
15094 int aggressive_scroll
= float_amount
;
15095 if (aggressive_scroll
== 0 && float_amount
> 0)
15096 aggressive_scroll
= 1;
15097 /* Don't let point enter the scroll margin near top of
15098 the window. This could happen if the value of
15099 scroll_up_aggressively is too large and there are
15100 non-zero margins, because scroll_up_aggressively
15101 means put point that fraction of window height
15102 _from_the_bottom_margin_. */
15103 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
15104 aggressive_scroll
= height
- 2*this_scroll_margin
;
15105 amount_to_scroll
= dy
+ aggressive_scroll
;
15109 if (amount_to_scroll
<= 0)
15110 return SCROLLING_FAILED
;
15112 start_display (&it
, w
, startp
);
15113 if (arg_scroll_conservatively
<= scroll_limit
)
15114 move_it_vertically (&it
, amount_to_scroll
);
15117 /* Extra precision for users who set scroll-conservatively
15118 to a large number: make sure the amount we scroll
15119 the window start is never less than amount_to_scroll,
15120 which was computed as distance from window bottom to
15121 point. This matters when lines at window top and lines
15122 below window bottom have different height. */
15124 void *it1data
= NULL
;
15125 /* We use a temporary it1 because line_bottom_y can modify
15126 its argument, if it moves one line down; see there. */
15129 SAVE_IT (it1
, it
, it1data
);
15130 start_y
= line_bottom_y (&it1
);
15132 RESTORE_IT (&it
, &it
, it1data
);
15133 move_it_by_lines (&it
, 1);
15134 SAVE_IT (it1
, it
, it1data
);
15135 } while (line_bottom_y (&it1
) - start_y
< amount_to_scroll
);
15138 /* If STARTP is unchanged, move it down another screen line. */
15139 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
15140 move_it_by_lines (&it
, 1);
15141 startp
= it
.current
.pos
;
15145 struct text_pos scroll_margin_pos
= startp
;
15148 /* See if point is inside the scroll margin at the top of the
15150 if (this_scroll_margin
)
15154 start_display (&it
, w
, startp
);
15155 y_start
= it
.current_y
;
15156 move_it_vertically (&it
, this_scroll_margin
);
15157 scroll_margin_pos
= it
.current
.pos
;
15158 /* If we didn't move enough before hitting ZV, request
15159 additional amount of scroll, to move point out of the
15161 if (IT_CHARPOS (it
) == ZV
15162 && it
.current_y
- y_start
< this_scroll_margin
)
15163 y_offset
= this_scroll_margin
- (it
.current_y
- y_start
);
15166 if (PT
< CHARPOS (scroll_margin_pos
))
15168 /* Point is in the scroll margin at the top of the window or
15169 above what is displayed in the window. */
15172 /* Compute the vertical distance from PT to the scroll
15173 margin position. Move as far as scroll_max allows, or
15174 one screenful, or 10 screen lines, whichever is largest.
15175 Give up if distance is greater than scroll_max or if we
15176 didn't reach the scroll margin position. */
15177 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
15178 start_display (&it
, w
, pos
);
15180 y_to_move
= max (it
.last_visible_y
,
15181 max (scroll_max
, 10 * frame_line_height
));
15182 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
15184 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
15185 dy
= it
.current_y
- y0
;
15186 if (dy
> scroll_max
15187 || IT_CHARPOS (it
) < CHARPOS (scroll_margin_pos
))
15188 return SCROLLING_FAILED
;
15190 /* Additional scroll for when ZV was too close to point. */
15193 /* Compute new window start. */
15194 start_display (&it
, w
, startp
);
15196 if (arg_scroll_conservatively
)
15197 amount_to_scroll
= max (dy
, frame_line_height
*
15198 max (scroll_step
, temp_scroll_step
));
15199 else if (scroll_step
|| temp_scroll_step
)
15200 amount_to_scroll
= scroll_max
;
15203 aggressive
= BVAR (current_buffer
, scroll_down_aggressively
);
15204 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
15205 if (NUMBERP (aggressive
))
15207 double float_amount
= XFLOATINT (aggressive
) * height
;
15208 int aggressive_scroll
= float_amount
;
15209 if (aggressive_scroll
== 0 && float_amount
> 0)
15210 aggressive_scroll
= 1;
15211 /* Don't let point enter the scroll margin near
15212 bottom of the window, if the value of
15213 scroll_down_aggressively happens to be too
15215 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
15216 aggressive_scroll
= height
- 2*this_scroll_margin
;
15217 amount_to_scroll
= dy
+ aggressive_scroll
;
15221 if (amount_to_scroll
<= 0)
15222 return SCROLLING_FAILED
;
15224 move_it_vertically_backward (&it
, amount_to_scroll
);
15225 startp
= it
.current
.pos
;
15229 /* Run window scroll functions. */
15230 startp
= run_window_scroll_functions (window
, startp
);
15232 /* Display the window. Give up if new fonts are loaded, or if point
15234 if (!try_window (window
, startp
, 0))
15235 rc
= SCROLLING_NEED_LARGER_MATRICES
;
15236 else if (w
->cursor
.vpos
< 0)
15238 clear_glyph_matrix (w
->desired_matrix
);
15239 rc
= SCROLLING_FAILED
;
15243 /* Maybe forget recorded base line for line number display. */
15244 if (!just_this_one_p
15245 || current_buffer
->clip_changed
15246 || BEG_UNCHANGED
< CHARPOS (startp
))
15247 w
->base_line_number
= 0;
15249 /* If cursor ends up on a partially visible line,
15250 treat that as being off the bottom of the screen. */
15251 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0)
15252 /* It's possible that the cursor is on the first line of the
15253 buffer, which is partially obscured due to a vscroll
15254 (Bug#7537). In that case, avoid looping forever. */
15255 && extra_scroll_margin_lines
< w
->desired_matrix
->nrows
- 1)
15257 clear_glyph_matrix (w
->desired_matrix
);
15258 ++extra_scroll_margin_lines
;
15261 rc
= SCROLLING_SUCCESS
;
15268 /* Compute a suitable window start for window W if display of W starts
15269 on a continuation line. Value is non-zero if a new window start
15272 The new window start will be computed, based on W's width, starting
15273 from the start of the continued line. It is the start of the
15274 screen line with the minimum distance from the old start W->start. */
15277 compute_window_start_on_continuation_line (struct window
*w
)
15279 struct text_pos pos
, start_pos
;
15280 int window_start_changed_p
= 0;
15282 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
15284 /* If window start is on a continuation line... Window start may be
15285 < BEGV in case there's invisible text at the start of the
15286 buffer (M-x rmail, for example). */
15287 if (CHARPOS (start_pos
) > BEGV
15288 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
15291 struct glyph_row
*row
;
15293 /* Handle the case that the window start is out of range. */
15294 if (CHARPOS (start_pos
) < BEGV
)
15295 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
15296 else if (CHARPOS (start_pos
) > ZV
)
15297 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
15299 /* Find the start of the continued line. This should be fast
15300 because find_newline is fast (newline cache). */
15301 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
15302 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
15303 row
, DEFAULT_FACE_ID
);
15304 reseat_at_previous_visible_line_start (&it
);
15306 /* If the line start is "too far" away from the window start,
15307 say it takes too much time to compute a new window start. */
15308 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
15309 /* PXW: Do we need upper bounds here? */
15310 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
15312 int min_distance
, distance
;
15314 /* Move forward by display lines to find the new window
15315 start. If window width was enlarged, the new start can
15316 be expected to be > the old start. If window width was
15317 decreased, the new window start will be < the old start.
15318 So, we're looking for the display line start with the
15319 minimum distance from the old window start. */
15320 pos
= it
.current
.pos
;
15321 min_distance
= INFINITY
;
15322 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
15323 distance
< min_distance
)
15325 min_distance
= distance
;
15326 pos
= it
.current
.pos
;
15327 if (it
.line_wrap
== WORD_WRAP
)
15329 /* Under WORD_WRAP, move_it_by_lines is likely to
15330 overshoot and stop not at the first, but the
15331 second character from the left margin. So in
15332 that case, we need a more tight control on the X
15333 coordinate of the iterator than move_it_by_lines
15334 promises in its contract. The method is to first
15335 go to the last (rightmost) visible character of a
15336 line, then move to the leftmost character on the
15337 next line in a separate call. */
15338 move_it_to (&it
, ZV
, it
.last_visible_x
, it
.current_y
, -1,
15339 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
15340 move_it_to (&it
, ZV
, 0,
15341 it
.current_y
+ it
.max_ascent
+ it
.max_descent
, -1,
15342 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
15345 move_it_by_lines (&it
, 1);
15348 /* Set the window start there. */
15349 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
15350 window_start_changed_p
= 1;
15354 return window_start_changed_p
;
15358 /* Try cursor movement in case text has not changed in window WINDOW,
15359 with window start STARTP. Value is
15361 CURSOR_MOVEMENT_SUCCESS if successful
15363 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
15365 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
15366 display. *SCROLL_STEP is set to 1, under certain circumstances, if
15367 we want to scroll as if scroll-step were set to 1. See the code.
15369 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
15370 which case we have to abort this redisplay, and adjust matrices
15375 CURSOR_MOVEMENT_SUCCESS
,
15376 CURSOR_MOVEMENT_CANNOT_BE_USED
,
15377 CURSOR_MOVEMENT_MUST_SCROLL
,
15378 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
15382 try_cursor_movement (Lisp_Object window
, struct text_pos startp
, int *scroll_step
)
15384 struct window
*w
= XWINDOW (window
);
15385 struct frame
*f
= XFRAME (w
->frame
);
15386 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
15389 if (inhibit_try_cursor_movement
)
15393 /* Previously, there was a check for Lisp integer in the
15394 if-statement below. Now, this field is converted to
15395 ptrdiff_t, thus zero means invalid position in a buffer. */
15396 eassert (w
->last_point
> 0);
15397 /* Likewise there was a check whether window_end_vpos is nil or larger
15398 than the window. Now window_end_vpos is int and so never nil, but
15399 let's leave eassert to check whether it fits in the window. */
15400 eassert (w
->window_end_vpos
< w
->current_matrix
->nrows
);
15402 /* Handle case where text has not changed, only point, and it has
15403 not moved off the frame. */
15404 if (/* Point may be in this window. */
15405 PT
>= CHARPOS (startp
)
15406 /* Selective display hasn't changed. */
15407 && !current_buffer
->clip_changed
15408 /* Function force-mode-line-update is used to force a thorough
15409 redisplay. It sets either windows_or_buffers_changed or
15410 update_mode_lines. So don't take a shortcut here for these
15412 && !update_mode_lines
15413 && !windows_or_buffers_changed
15414 && !f
->cursor_type_changed
15415 && NILP (Vshow_trailing_whitespace
)
15416 /* This code is not used for mini-buffer for the sake of the case
15417 of redisplaying to replace an echo area message; since in
15418 that case the mini-buffer contents per se are usually
15419 unchanged. This code is of no real use in the mini-buffer
15420 since the handling of this_line_start_pos, etc., in redisplay
15421 handles the same cases. */
15422 && !EQ (window
, minibuf_window
)
15423 && (FRAME_WINDOW_P (f
)
15424 || !overlay_arrow_in_current_buffer_p ()))
15426 int this_scroll_margin
, top_scroll_margin
;
15427 struct glyph_row
*row
= NULL
;
15428 int frame_line_height
= default_line_pixel_height (w
);
15429 int window_total_lines
15430 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) / frame_line_height
;
15433 debug_method_add (w
, "cursor movement");
15436 /* Scroll if point within this distance from the top or bottom
15437 of the window. This is a pixel value. */
15438 if (scroll_margin
> 0)
15440 this_scroll_margin
= min (scroll_margin
, window_total_lines
/ 4);
15441 this_scroll_margin
*= frame_line_height
;
15444 this_scroll_margin
= 0;
15446 top_scroll_margin
= this_scroll_margin
;
15447 if (WINDOW_WANTS_HEADER_LINE_P (w
))
15448 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
15450 /* Start with the row the cursor was displayed during the last
15451 not paused redisplay. Give up if that row is not valid. */
15452 if (w
->last_cursor_vpos
< 0
15453 || w
->last_cursor_vpos
>= w
->current_matrix
->nrows
)
15454 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15457 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor_vpos
);
15458 if (row
->mode_line_p
)
15460 if (!row
->enabled_p
)
15461 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15464 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
15466 int scroll_p
= 0, must_scroll
= 0;
15467 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
15469 if (PT
> w
->last_point
)
15471 /* Point has moved forward. */
15472 while (MATRIX_ROW_END_CHARPOS (row
) < PT
15473 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
15475 eassert (row
->enabled_p
);
15479 /* If the end position of a row equals the start
15480 position of the next row, and PT is at that position,
15481 we would rather display cursor in the next line. */
15482 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15483 && MATRIX_ROW_END_CHARPOS (row
) == PT
15484 && row
< MATRIX_MODE_LINE_ROW (w
->current_matrix
)
15485 && MATRIX_ROW_START_CHARPOS (row
+1) == PT
15486 && !cursor_row_p (row
))
15489 /* If within the scroll margin, scroll. Note that
15490 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
15491 the next line would be drawn, and that
15492 this_scroll_margin can be zero. */
15493 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
15494 || PT
> MATRIX_ROW_END_CHARPOS (row
)
15495 /* Line is completely visible last line in window
15496 and PT is to be set in the next line. */
15497 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
15498 && PT
== MATRIX_ROW_END_CHARPOS (row
)
15499 && !row
->ends_at_zv_p
15500 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
15503 else if (PT
< w
->last_point
)
15505 /* Cursor has to be moved backward. Note that PT >=
15506 CHARPOS (startp) because of the outer if-statement. */
15507 while (!row
->mode_line_p
15508 && (MATRIX_ROW_START_CHARPOS (row
) > PT
15509 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15510 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
15511 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
15512 row
> w
->current_matrix
->rows
15513 && (row
-1)->ends_in_newline_from_string_p
))))
15514 && (row
->y
> top_scroll_margin
15515 || CHARPOS (startp
) == BEGV
))
15517 eassert (row
->enabled_p
);
15521 /* Consider the following case: Window starts at BEGV,
15522 there is invisible, intangible text at BEGV, so that
15523 display starts at some point START > BEGV. It can
15524 happen that we are called with PT somewhere between
15525 BEGV and START. Try to handle that case. */
15526 if (row
< w
->current_matrix
->rows
15527 || row
->mode_line_p
)
15529 row
= w
->current_matrix
->rows
;
15530 if (row
->mode_line_p
)
15534 /* Due to newlines in overlay strings, we may have to
15535 skip forward over overlay strings. */
15536 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15537 && MATRIX_ROW_END_CHARPOS (row
) == PT
15538 && !cursor_row_p (row
))
15541 /* If within the scroll margin, scroll. */
15542 if (row
->y
< top_scroll_margin
15543 && CHARPOS (startp
) != BEGV
)
15548 /* Cursor did not move. So don't scroll even if cursor line
15549 is partially visible, as it was so before. */
15550 rc
= CURSOR_MOVEMENT_SUCCESS
;
15553 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
15554 || PT
> MATRIX_ROW_END_CHARPOS (row
))
15556 /* if PT is not in the glyph row, give up. */
15557 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15560 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15561 && !NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
)))
15563 struct glyph_row
*row1
;
15565 /* If rows are bidi-reordered and point moved, back up
15566 until we find a row that does not belong to a
15567 continuation line. This is because we must consider
15568 all rows of a continued line as candidates for the
15569 new cursor positioning, since row start and end
15570 positions change non-linearly with vertical position
15572 /* FIXME: Revisit this when glyph ``spilling'' in
15573 continuation lines' rows is implemented for
15574 bidi-reordered rows. */
15575 for (row1
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15576 MATRIX_ROW_CONTINUATION_LINE_P (row
);
15579 /* If we hit the beginning of the displayed portion
15580 without finding the first row of a continued
15584 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15587 eassert (row
->enabled_p
);
15592 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15593 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
15594 /* Make sure this isn't a header line by any chance, since
15595 then MATRIX_ROW_PARTIALLY_VISIBLE_P might yield non-zero. */
15596 && !row
->mode_line_p
15597 && make_cursor_line_fully_visible_p
)
15599 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
15600 && !row
->ends_at_zv_p
15601 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
15602 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15603 else if (row
->height
> window_box_height (w
))
15605 /* If we end up in a partially visible line, let's
15606 make it fully visible, except when it's taller
15607 than the window, in which case we can't do much
15610 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15614 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15615 if (!cursor_row_fully_visible_p (w
, 0, 1))
15616 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15618 rc
= CURSOR_MOVEMENT_SUCCESS
;
15622 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15623 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15624 && !NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
)))
15626 /* With bidi-reordered rows, there could be more than
15627 one candidate row whose start and end positions
15628 occlude point. We need to let set_cursor_from_row
15629 find the best candidate. */
15630 /* FIXME: Revisit this when glyph ``spilling'' in
15631 continuation lines' rows is implemented for
15632 bidi-reordered rows. */
15637 int at_zv_p
= 0, exact_match_p
= 0;
15639 if (MATRIX_ROW_START_CHARPOS (row
) <= PT
15640 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
15641 && cursor_row_p (row
))
15642 rv
|= set_cursor_from_row (w
, row
, w
->current_matrix
,
15644 /* As soon as we've found the exact match for point,
15645 or the first suitable row whose ends_at_zv_p flag
15646 is set, we are done. */
15649 at_zv_p
= MATRIX_ROW (w
->current_matrix
,
15650 w
->cursor
.vpos
)->ends_at_zv_p
;
15652 && w
->cursor
.hpos
>= 0
15653 && w
->cursor
.hpos
< MATRIX_ROW_USED (w
->current_matrix
,
15656 struct glyph_row
*candidate
=
15657 MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
15659 candidate
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
15660 ptrdiff_t endpos
= MATRIX_ROW_END_CHARPOS (candidate
);
15663 (BUFFERP (g
->object
) && g
->charpos
== PT
)
15664 || (INTEGERP (g
->object
)
15665 && (g
->charpos
== PT
15666 || (g
->charpos
== 0 && endpos
- 1 == PT
)));
15668 if (at_zv_p
|| exact_match_p
)
15670 rc
= CURSOR_MOVEMENT_SUCCESS
;
15674 if (MATRIX_ROW_BOTTOM_Y (row
) == last_y
)
15678 while (((MATRIX_ROW_CONTINUATION_LINE_P (row
)
15679 || row
->continued_p
)
15680 && MATRIX_ROW_BOTTOM_Y (row
) <= last_y
)
15681 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15682 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
));
15683 /* If we didn't find any candidate rows, or exited the
15684 loop before all the candidates were examined, signal
15685 to the caller that this method failed. */
15686 if (rc
!= CURSOR_MOVEMENT_SUCCESS
15688 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
15689 && !row
->continued_p
))
15690 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15692 rc
= CURSOR_MOVEMENT_SUCCESS
;
15698 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
15700 rc
= CURSOR_MOVEMENT_SUCCESS
;
15705 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15706 && MATRIX_ROW_START_CHARPOS (row
) == PT
15707 && cursor_row_p (row
));
15716 set_vertical_scroll_bar (struct window
*w
)
15718 ptrdiff_t start
, end
, whole
;
15720 /* Calculate the start and end positions for the current window.
15721 At some point, it would be nice to choose between scrollbars
15722 which reflect the whole buffer size, with special markers
15723 indicating narrowing, and scrollbars which reflect only the
15726 Note that mini-buffers sometimes aren't displaying any text. */
15727 if (!MINI_WINDOW_P (w
)
15728 || (w
== XWINDOW (minibuf_window
)
15729 && NILP (echo_area_buffer
[0])))
15731 struct buffer
*buf
= XBUFFER (w
->contents
);
15732 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
15733 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
15734 /* I don't think this is guaranteed to be right. For the
15735 moment, we'll pretend it is. */
15736 end
= BUF_Z (buf
) - w
->window_end_pos
- BUF_BEGV (buf
);
15740 if (whole
< (end
- start
))
15741 whole
= end
- start
;
15744 start
= end
= whole
= 0;
15746 /* Indicate what this scroll bar ought to be displaying now. */
15747 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15748 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15749 (w
, end
- start
, whole
, start
);
15753 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
15754 selected_window is redisplayed.
15756 We can return without actually redisplaying the window if fonts has been
15757 changed on window's frame. In that case, redisplay_internal will retry.
15759 As one of the important parts of redisplaying a window, we need to
15760 decide whether the previous window-start position (stored in the
15761 window's w->start marker position) is still valid, and if it isn't,
15762 recompute it. Some details about that:
15764 . The previous window-start could be in a continuation line, in
15765 which case we need to recompute it when the window width
15766 changes. See compute_window_start_on_continuation_line and its
15769 . The text that changed since last redisplay could include the
15770 previous window-start position. In that case, we try to salvage
15771 what we can from the current glyph matrix by calling
15772 try_scrolling, which see.
15774 . Some Emacs command could force us to use a specific window-start
15775 position by setting the window's force_start flag, or gently
15776 propose doing that by setting the window's optional_new_start
15777 flag. In these cases, we try using the specified start point if
15778 that succeeds (i.e. the window desired matrix is successfully
15779 recomputed, and point location is within the window). In case
15780 of optional_new_start, we first check if the specified start
15781 position is feasible, i.e. if it will allow point to be
15782 displayed in the window. If using the specified start point
15783 fails, e.g., if new fonts are needed to be loaded, we abort the
15784 redisplay cycle and leave it up to the next cycle to figure out
15787 . Note that the window's force_start flag is sometimes set by
15788 redisplay itself, when it decides that the previous window start
15789 point is fine and should be kept. Search for "goto force_start"
15790 below to see the details. Like the values of window-start
15791 specified outside of redisplay, these internally-deduced values
15792 are tested for feasibility, and ignored if found to be
15795 . Note that the function try_window, used to completely redisplay
15796 a window, accepts the window's start point as its argument.
15797 This is used several times in the redisplay code to control
15798 where the window start will be, according to user options such
15799 as scroll-conservatively, and also to ensure the screen line
15800 showing point will be fully (as opposed to partially) visible on
15804 redisplay_window (Lisp_Object window
, bool just_this_one_p
)
15806 struct window
*w
= XWINDOW (window
);
15807 struct frame
*f
= XFRAME (w
->frame
);
15808 struct buffer
*buffer
= XBUFFER (w
->contents
);
15809 struct buffer
*old
= current_buffer
;
15810 struct text_pos lpoint
, opoint
, startp
;
15811 int update_mode_line
;
15814 /* Record it now because it's overwritten. */
15815 bool current_matrix_up_to_date_p
= false;
15816 bool used_current_matrix_p
= false;
15817 /* This is less strict than current_matrix_up_to_date_p.
15818 It indicates that the buffer contents and narrowing are unchanged. */
15819 bool buffer_unchanged_p
= false;
15820 int temp_scroll_step
= 0;
15821 ptrdiff_t count
= SPECPDL_INDEX ();
15823 int centering_position
= -1;
15824 int last_line_misfit
= 0;
15825 ptrdiff_t beg_unchanged
, end_unchanged
;
15826 int frame_line_height
;
15828 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
15832 *w
->desired_matrix
->method
= 0;
15835 if (!just_this_one_p
15836 && REDISPLAY_SOME_P ()
15839 && !buffer
->text
->redisplay
15840 && BUF_PT (buffer
) == w
->last_point
)
15843 /* Make sure that both W's markers are valid. */
15844 eassert (XMARKER (w
->start
)->buffer
== buffer
);
15845 eassert (XMARKER (w
->pointm
)->buffer
== buffer
);
15847 /* We come here again if we need to run window-text-change-functions
15850 reconsider_clip_changes (w
);
15851 frame_line_height
= default_line_pixel_height (w
);
15853 /* Has the mode line to be updated? */
15854 update_mode_line
= (w
->update_mode_line
15855 || update_mode_lines
15856 || buffer
->clip_changed
15857 || buffer
->prevent_redisplay_optimizations_p
);
15859 if (!just_this_one_p
)
15860 /* If `just_this_one_p' is set, we apparently set must_be_updated_p more
15861 cleverly elsewhere. */
15862 w
->must_be_updated_p
= true;
15864 if (MINI_WINDOW_P (w
))
15866 if (w
== XWINDOW (echo_area_window
)
15867 && !NILP (echo_area_buffer
[0]))
15869 if (update_mode_line
)
15870 /* We may have to update a tty frame's menu bar or a
15871 tool-bar. Example `M-x C-h C-h C-g'. */
15872 goto finish_menu_bars
;
15874 /* We've already displayed the echo area glyphs in this window. */
15875 goto finish_scroll_bars
;
15877 else if ((w
!= XWINDOW (minibuf_window
)
15878 || minibuf_level
== 0)
15879 /* When buffer is nonempty, redisplay window normally. */
15880 && BUF_Z (XBUFFER (w
->contents
)) == BUF_BEG (XBUFFER (w
->contents
))
15881 /* Quail displays non-mini buffers in minibuffer window.
15882 In that case, redisplay the window normally. */
15883 && !NILP (Fmemq (w
->contents
, Vminibuffer_list
)))
15885 /* W is a mini-buffer window, but it's not active, so clear
15887 int yb
= window_text_bottom_y (w
);
15888 struct glyph_row
*row
;
15891 for (y
= 0, row
= w
->desired_matrix
->rows
;
15893 y
+= row
->height
, ++row
)
15894 blank_row (w
, row
, y
);
15895 goto finish_scroll_bars
;
15898 clear_glyph_matrix (w
->desired_matrix
);
15901 /* Otherwise set up data on this window; select its buffer and point
15903 /* Really select the buffer, for the sake of buffer-local
15905 set_buffer_internal_1 (XBUFFER (w
->contents
));
15907 current_matrix_up_to_date_p
15908 = (w
->window_end_valid
15909 && !current_buffer
->clip_changed
15910 && !current_buffer
->prevent_redisplay_optimizations_p
15911 && !window_outdated (w
));
15913 /* Run the window-text-change-functions
15914 if it is possible that the text on the screen has changed
15915 (either due to modification of the text, or any other reason). */
15916 if (!current_matrix_up_to_date_p
15917 && !NILP (Vwindow_text_change_functions
))
15919 safe_run_hooks (Qwindow_text_change_functions
);
15923 beg_unchanged
= BEG_UNCHANGED
;
15924 end_unchanged
= END_UNCHANGED
;
15926 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
15928 specbind (Qinhibit_point_motion_hooks
, Qt
);
15931 = (w
->window_end_valid
15932 && !current_buffer
->clip_changed
15933 && !window_outdated (w
));
15935 /* When windows_or_buffers_changed is non-zero, we can't rely
15936 on the window end being valid, so set it to zero there. */
15937 if (windows_or_buffers_changed
)
15939 /* If window starts on a continuation line, maybe adjust the
15940 window start in case the window's width changed. */
15941 if (XMARKER (w
->start
)->buffer
== current_buffer
)
15942 compute_window_start_on_continuation_line (w
);
15944 w
->window_end_valid
= false;
15945 /* If so, we also can't rely on current matrix
15946 and should not fool try_cursor_movement below. */
15947 current_matrix_up_to_date_p
= false;
15950 /* Some sanity checks. */
15951 CHECK_WINDOW_END (w
);
15952 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
15954 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
15957 if (mode_line_update_needed (w
))
15958 update_mode_line
= 1;
15960 /* Point refers normally to the selected window. For any other
15961 window, set up appropriate value. */
15962 if (!EQ (window
, selected_window
))
15964 ptrdiff_t new_pt
= marker_position (w
->pointm
);
15965 ptrdiff_t new_pt_byte
= marker_byte_position (w
->pointm
);
15969 new_pt_byte
= BEGV_BYTE
;
15970 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
15972 else if (new_pt
> (ZV
- 1))
15975 new_pt_byte
= ZV_BYTE
;
15976 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
15979 /* We don't use SET_PT so that the point-motion hooks don't run. */
15980 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
15983 /* If any of the character widths specified in the display table
15984 have changed, invalidate the width run cache. It's true that
15985 this may be a bit late to catch such changes, but the rest of
15986 redisplay goes (non-fatally) haywire when the display table is
15987 changed, so why should we worry about doing any better? */
15988 if (current_buffer
->width_run_cache
15989 || (current_buffer
->base_buffer
15990 && current_buffer
->base_buffer
->width_run_cache
))
15992 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
15994 if (! disptab_matches_widthtab
15995 (disptab
, XVECTOR (BVAR (current_buffer
, width_table
))))
15997 struct buffer
*buf
= current_buffer
;
15999 if (buf
->base_buffer
)
16000 buf
= buf
->base_buffer
;
16001 invalidate_region_cache (buf
, buf
->width_run_cache
, BEG
, Z
);
16002 recompute_width_table (current_buffer
, disptab
);
16006 /* If window-start is screwed up, choose a new one. */
16007 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
16010 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
16012 /* If someone specified a new starting point but did not insist,
16013 check whether it can be used. */
16014 if (w
->optional_new_start
16015 && CHARPOS (startp
) >= BEGV
16016 && CHARPOS (startp
) <= ZV
)
16018 w
->optional_new_start
= 0;
16019 start_display (&it
, w
, startp
);
16020 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
16021 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
16022 if (IT_CHARPOS (it
) == PT
)
16023 w
->force_start
= 1;
16024 /* IT may overshoot PT if text at PT is invisible. */
16025 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
16026 w
->force_start
= 1;
16031 /* Handle case where place to start displaying has been specified,
16032 unless the specified location is outside the accessible range. */
16033 if (w
->force_start
|| window_frozen_p (w
))
16035 /* We set this later on if we have to adjust point. */
16038 w
->force_start
= 0;
16040 w
->window_end_valid
= 0;
16042 /* Forget any recorded base line for line number display. */
16043 if (!buffer_unchanged_p
)
16044 w
->base_line_number
= 0;
16046 /* Redisplay the mode line. Select the buffer properly for that.
16047 Also, run the hook window-scroll-functions
16048 because we have scrolled. */
16049 /* Note, we do this after clearing force_start because
16050 if there's an error, it is better to forget about force_start
16051 than to get into an infinite loop calling the hook functions
16052 and having them get more errors. */
16053 if (!update_mode_line
16054 || ! NILP (Vwindow_scroll_functions
))
16056 update_mode_line
= 1;
16057 w
->update_mode_line
= 1;
16058 startp
= run_window_scroll_functions (window
, startp
);
16061 if (CHARPOS (startp
) < BEGV
)
16062 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
16063 else if (CHARPOS (startp
) > ZV
)
16064 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
16066 /* Redisplay, then check if cursor has been set during the
16067 redisplay. Give up if new fonts were loaded. */
16068 /* We used to issue a CHECK_MARGINS argument to try_window here,
16069 but this causes scrolling to fail when point begins inside
16070 the scroll margin (bug#148) -- cyd */
16071 if (!try_window (window
, startp
, 0))
16073 w
->force_start
= 1;
16074 clear_glyph_matrix (w
->desired_matrix
);
16075 goto need_larger_matrices
;
16078 if (w
->cursor
.vpos
< 0 && !window_frozen_p (w
))
16080 /* If point does not appear, try to move point so it does
16081 appear. The desired matrix has been built above, so we
16082 can use it here. */
16083 new_vpos
= window_box_height (w
) / 2;
16086 if (!cursor_row_fully_visible_p (w
, 0, 0))
16088 /* Point does appear, but on a line partly visible at end of window.
16089 Move it back to a fully-visible line. */
16090 new_vpos
= window_box_height (w
);
16092 else if (w
->cursor
.vpos
>= 0)
16094 /* Some people insist on not letting point enter the scroll
16095 margin, even though this part handles windows that didn't
16097 int window_total_lines
16098 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) / frame_line_height
;
16099 int margin
= min (scroll_margin
, window_total_lines
/ 4);
16100 int pixel_margin
= margin
* frame_line_height
;
16101 bool header_line
= WINDOW_WANTS_HEADER_LINE_P (w
);
16103 /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
16104 below, which finds the row to move point to, advances by
16105 the Y coordinate of the _next_ row, see the definition of
16106 MATRIX_ROW_BOTTOM_Y. */
16107 if (w
->cursor
.vpos
< margin
+ header_line
)
16109 w
->cursor
.vpos
= -1;
16110 clear_glyph_matrix (w
->desired_matrix
);
16111 goto try_to_scroll
;
16115 int window_height
= window_box_height (w
);
16118 window_height
+= CURRENT_HEADER_LINE_HEIGHT (w
);
16119 if (w
->cursor
.y
>= window_height
- pixel_margin
)
16121 w
->cursor
.vpos
= -1;
16122 clear_glyph_matrix (w
->desired_matrix
);
16123 goto try_to_scroll
;
16128 /* If we need to move point for either of the above reasons,
16129 now actually do it. */
16132 struct glyph_row
*row
;
16134 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
16135 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
16138 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
16139 MATRIX_ROW_START_BYTEPOS (row
));
16141 if (w
!= XWINDOW (selected_window
))
16142 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
16143 else if (current_buffer
== old
)
16144 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
16146 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
16148 /* If we are highlighting the region, then we just changed
16149 the region, so redisplay to show it. */
16150 /* FIXME: We need to (re)run pre-redisplay-function! */
16151 /* if (markpos_of_region () >= 0)
16153 clear_glyph_matrix (w->desired_matrix);
16154 if (!try_window (window, startp, 0))
16155 goto need_larger_matrices;
16161 debug_method_add (w
, "forced window start");
16166 /* Handle case where text has not changed, only point, and it has
16167 not moved off the frame, and we are not retrying after hscroll.
16168 (current_matrix_up_to_date_p is nonzero when retrying.) */
16169 if (current_matrix_up_to_date_p
16170 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
16171 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
16175 case CURSOR_MOVEMENT_SUCCESS
:
16176 used_current_matrix_p
= 1;
16179 case CURSOR_MOVEMENT_MUST_SCROLL
:
16180 goto try_to_scroll
;
16186 /* If current starting point was originally the beginning of a line
16187 but no longer is, find a new starting point. */
16188 else if (w
->start_at_line_beg
16189 && !(CHARPOS (startp
) <= BEGV
16190 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
16193 debug_method_add (w
, "recenter 1");
16198 /* Try scrolling with try_window_id. Value is > 0 if update has
16199 been done, it is -1 if we know that the same window start will
16200 not work. It is 0 if unsuccessful for some other reason. */
16201 else if ((tem
= try_window_id (w
)) != 0)
16204 debug_method_add (w
, "try_window_id %d", tem
);
16207 if (f
->fonts_changed
)
16208 goto need_larger_matrices
;
16212 /* Otherwise try_window_id has returned -1 which means that we
16213 don't want the alternative below this comment to execute. */
16215 else if (CHARPOS (startp
) >= BEGV
16216 && CHARPOS (startp
) <= ZV
16217 && PT
>= CHARPOS (startp
)
16218 && (CHARPOS (startp
) < ZV
16219 /* Avoid starting at end of buffer. */
16220 || CHARPOS (startp
) == BEGV
16221 || !window_outdated (w
)))
16223 int d1
, d2
, d3
, d4
, d5
, d6
;
16225 /* If first window line is a continuation line, and window start
16226 is inside the modified region, but the first change is before
16227 current window start, we must select a new window start.
16229 However, if this is the result of a down-mouse event (e.g. by
16230 extending the mouse-drag-overlay), we don't want to select a
16231 new window start, since that would change the position under
16232 the mouse, resulting in an unwanted mouse-movement rather
16233 than a simple mouse-click. */
16234 if (!w
->start_at_line_beg
16235 && NILP (do_mouse_tracking
)
16236 && CHARPOS (startp
) > BEGV
16237 && CHARPOS (startp
) > BEG
+ beg_unchanged
16238 && CHARPOS (startp
) <= Z
- end_unchanged
16239 /* Even if w->start_at_line_beg is nil, a new window may
16240 start at a line_beg, since that's how set_buffer_window
16241 sets it. So, we need to check the return value of
16242 compute_window_start_on_continuation_line. (See also
16244 && XMARKER (w
->start
)->buffer
== current_buffer
16245 && compute_window_start_on_continuation_line (w
)
16246 /* It doesn't make sense to force the window start like we
16247 do at label force_start if it is already known that point
16248 will not be visible in the resulting window, because
16249 doing so will move point from its correct position
16250 instead of scrolling the window to bring point into view.
16252 && pos_visible_p (w
, PT
, &d1
, &d2
, &d3
, &d4
, &d5
, &d6
))
16254 w
->force_start
= 1;
16255 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
16260 debug_method_add (w
, "same window start");
16263 /* Try to redisplay starting at same place as before.
16264 If point has not moved off frame, accept the results. */
16265 if (!current_matrix_up_to_date_p
16266 /* Don't use try_window_reusing_current_matrix in this case
16267 because a window scroll function can have changed the
16269 || !NILP (Vwindow_scroll_functions
)
16270 || MINI_WINDOW_P (w
)
16271 || !(used_current_matrix_p
16272 = try_window_reusing_current_matrix (w
)))
16274 IF_DEBUG (debug_method_add (w
, "1"));
16275 if (try_window (window
, startp
, TRY_WINDOW_CHECK_MARGINS
) < 0)
16276 /* -1 means we need to scroll.
16277 0 means we need new matrices, but fonts_changed
16278 is set in that case, so we will detect it below. */
16279 goto try_to_scroll
;
16282 if (f
->fonts_changed
)
16283 goto need_larger_matrices
;
16285 if (w
->cursor
.vpos
>= 0)
16287 if (!just_this_one_p
16288 || current_buffer
->clip_changed
16289 || BEG_UNCHANGED
< CHARPOS (startp
))
16290 /* Forget any recorded base line for line number display. */
16291 w
->base_line_number
= 0;
16293 if (!cursor_row_fully_visible_p (w
, 1, 0))
16295 clear_glyph_matrix (w
->desired_matrix
);
16296 last_line_misfit
= 1;
16298 /* Drop through and scroll. */
16303 clear_glyph_matrix (w
->desired_matrix
);
16308 /* Redisplay the mode line. Select the buffer properly for that. */
16309 if (!update_mode_line
)
16311 update_mode_line
= 1;
16312 w
->update_mode_line
= 1;
16315 /* Try to scroll by specified few lines. */
16316 if ((scroll_conservatively
16317 || emacs_scroll_step
16318 || temp_scroll_step
16319 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
))
16320 || NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
)))
16321 && CHARPOS (startp
) >= BEGV
16322 && CHARPOS (startp
) <= ZV
)
16324 /* The function returns -1 if new fonts were loaded, 1 if
16325 successful, 0 if not successful. */
16326 int ss
= try_scrolling (window
, just_this_one_p
,
16327 scroll_conservatively
,
16329 temp_scroll_step
, last_line_misfit
);
16332 case SCROLLING_SUCCESS
:
16335 case SCROLLING_NEED_LARGER_MATRICES
:
16336 goto need_larger_matrices
;
16338 case SCROLLING_FAILED
:
16346 /* Finally, just choose a place to start which positions point
16347 according to user preferences. */
16352 debug_method_add (w
, "recenter");
16355 /* Forget any previously recorded base line for line number display. */
16356 if (!buffer_unchanged_p
)
16357 w
->base_line_number
= 0;
16359 /* Determine the window start relative to point. */
16360 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
16361 it
.current_y
= it
.last_visible_y
;
16362 if (centering_position
< 0)
16364 int window_total_lines
16365 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) / frame_line_height
;
16368 ? min (scroll_margin
, window_total_lines
/ 4)
16370 ptrdiff_t margin_pos
= CHARPOS (startp
);
16371 Lisp_Object aggressive
;
16374 /* If there is a scroll margin at the top of the window, find
16375 its character position. */
16377 /* Cannot call start_display if startp is not in the
16378 accessible region of the buffer. This can happen when we
16379 have just switched to a different buffer and/or changed
16380 its restriction. In that case, startp is initialized to
16381 the character position 1 (BEGV) because we did not yet
16382 have chance to display the buffer even once. */
16383 && BEGV
<= CHARPOS (startp
) && CHARPOS (startp
) <= ZV
)
16386 void *it1data
= NULL
;
16388 SAVE_IT (it1
, it
, it1data
);
16389 start_display (&it1
, w
, startp
);
16390 move_it_vertically (&it1
, margin
* frame_line_height
);
16391 margin_pos
= IT_CHARPOS (it1
);
16392 RESTORE_IT (&it
, &it
, it1data
);
16394 scrolling_up
= PT
> margin_pos
;
16397 ? BVAR (current_buffer
, scroll_up_aggressively
)
16398 : BVAR (current_buffer
, scroll_down_aggressively
);
16400 if (!MINI_WINDOW_P (w
)
16401 && (scroll_conservatively
> SCROLL_LIMIT
|| NUMBERP (aggressive
)))
16405 /* Setting scroll-conservatively overrides
16406 scroll-*-aggressively. */
16407 if (!scroll_conservatively
&& NUMBERP (aggressive
))
16409 double float_amount
= XFLOATINT (aggressive
);
16411 pt_offset
= float_amount
* WINDOW_BOX_TEXT_HEIGHT (w
);
16412 if (pt_offset
== 0 && float_amount
> 0)
16414 if (pt_offset
&& margin
> 0)
16417 /* Compute how much to move the window start backward from
16418 point so that point will be displayed where the user
16422 centering_position
= it
.last_visible_y
;
16424 centering_position
-= pt_offset
;
16425 centering_position
-=
16426 frame_line_height
* (1 + margin
+ (last_line_misfit
!= 0))
16427 + WINDOW_HEADER_LINE_HEIGHT (w
);
16428 /* Don't let point enter the scroll margin near top of
16430 if (centering_position
< margin
* frame_line_height
)
16431 centering_position
= margin
* frame_line_height
;
16434 centering_position
= margin
* frame_line_height
+ pt_offset
;
16437 /* Set the window start half the height of the window backward
16439 centering_position
= window_box_height (w
) / 2;
16441 move_it_vertically_backward (&it
, centering_position
);
16443 eassert (IT_CHARPOS (it
) >= BEGV
);
16445 /* The function move_it_vertically_backward may move over more
16446 than the specified y-distance. If it->w is small, e.g. a
16447 mini-buffer window, we may end up in front of the window's
16448 display area. Start displaying at the start of the line
16449 containing PT in this case. */
16450 if (it
.current_y
<= 0)
16452 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
16453 move_it_vertically_backward (&it
, 0);
16457 it
.current_x
= it
.hpos
= 0;
16459 /* Set the window start position here explicitly, to avoid an
16460 infinite loop in case the functions in window-scroll-functions
16462 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
16464 /* Run scroll hooks. */
16465 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
16467 /* Redisplay the window. */
16468 if (!current_matrix_up_to_date_p
16469 || windows_or_buffers_changed
16470 || f
->cursor_type_changed
16471 /* Don't use try_window_reusing_current_matrix in this case
16472 because it can have changed the buffer. */
16473 || !NILP (Vwindow_scroll_functions
)
16474 || !just_this_one_p
16475 || MINI_WINDOW_P (w
)
16476 || !(used_current_matrix_p
16477 = try_window_reusing_current_matrix (w
)))
16478 try_window (window
, startp
, 0);
16480 /* If new fonts have been loaded (due to fontsets), give up. We
16481 have to start a new redisplay since we need to re-adjust glyph
16483 if (f
->fonts_changed
)
16484 goto need_larger_matrices
;
16486 /* If cursor did not appear assume that the middle of the window is
16487 in the first line of the window. Do it again with the next line.
16488 (Imagine a window of height 100, displaying two lines of height
16489 60. Moving back 50 from it->last_visible_y will end in the first
16491 if (w
->cursor
.vpos
< 0)
16493 if (w
->window_end_valid
&& PT
>= Z
- w
->window_end_pos
)
16495 clear_glyph_matrix (w
->desired_matrix
);
16496 move_it_by_lines (&it
, 1);
16497 try_window (window
, it
.current
.pos
, 0);
16499 else if (PT
< IT_CHARPOS (it
))
16501 clear_glyph_matrix (w
->desired_matrix
);
16502 move_it_by_lines (&it
, -1);
16503 try_window (window
, it
.current
.pos
, 0);
16507 /* Not much we can do about it. */
16511 /* Consider the following case: Window starts at BEGV, there is
16512 invisible, intangible text at BEGV, so that display starts at
16513 some point START > BEGV. It can happen that we are called with
16514 PT somewhere between BEGV and START. Try to handle that case,
16515 and similar ones. */
16516 if (w
->cursor
.vpos
< 0)
16518 /* First, try locating the proper glyph row for PT. */
16519 struct glyph_row
*row
=
16520 row_containing_pos (w
, PT
, w
->current_matrix
->rows
, NULL
, 0);
16522 /* Sometimes point is at the beginning of invisible text that is
16523 before the 1st character displayed in the row. In that case,
16524 row_containing_pos fails to find the row, because no glyphs
16525 with appropriate buffer positions are present in the row.
16526 Therefore, we next try to find the row which shows the 1st
16527 position after the invisible text. */
16531 get_char_property_and_overlay (make_number (PT
), Qinvisible
,
16534 if (TEXT_PROP_MEANS_INVISIBLE (val
))
16537 Lisp_Object invis_end
=
16538 Fnext_single_char_property_change (make_number (PT
), Qinvisible
,
16541 if (NATNUMP (invis_end
))
16542 alt_pos
= XFASTINT (invis_end
);
16545 row
= row_containing_pos (w
, alt_pos
, w
->current_matrix
->rows
,
16549 /* Finally, fall back on the first row of the window after the
16550 header line (if any). This is slightly better than not
16551 displaying the cursor at all. */
16554 row
= w
->current_matrix
->rows
;
16555 if (row
->mode_line_p
)
16558 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
16561 if (!cursor_row_fully_visible_p (w
, 0, 0))
16563 /* If vscroll is enabled, disable it and try again. */
16567 clear_glyph_matrix (w
->desired_matrix
);
16571 /* Users who set scroll-conservatively to a large number want
16572 point just above/below the scroll margin. If we ended up
16573 with point's row partially visible, move the window start to
16574 make that row fully visible and out of the margin. */
16575 if (scroll_conservatively
> SCROLL_LIMIT
)
16577 int window_total_lines
16578 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) * frame_line_height
;
16581 ? min (scroll_margin
, window_total_lines
/ 4)
16583 int move_down
= w
->cursor
.vpos
>= window_total_lines
/ 2;
16585 move_it_by_lines (&it
, move_down
? margin
+ 1 : -(margin
+ 1));
16586 clear_glyph_matrix (w
->desired_matrix
);
16587 if (1 == try_window (window
, it
.current
.pos
,
16588 TRY_WINDOW_CHECK_MARGINS
))
16592 /* If centering point failed to make the whole line visible,
16593 put point at the top instead. That has to make the whole line
16594 visible, if it can be done. */
16595 if (centering_position
== 0)
16598 clear_glyph_matrix (w
->desired_matrix
);
16599 centering_position
= 0;
16605 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
16606 w
->start_at_line_beg
= (CHARPOS (startp
) == BEGV
16607 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n');
16609 /* Display the mode line, if we must. */
16610 if ((update_mode_line
16611 /* If window not full width, must redo its mode line
16612 if (a) the window to its side is being redone and
16613 (b) we do a frame-based redisplay. This is a consequence
16614 of how inverted lines are drawn in frame-based redisplay. */
16615 || (!just_this_one_p
16616 && !FRAME_WINDOW_P (f
)
16617 && !WINDOW_FULL_WIDTH_P (w
))
16618 /* Line number to display. */
16619 || w
->base_line_pos
> 0
16620 /* Column number is displayed and different from the one displayed. */
16621 || (w
->column_number_displayed
!= -1
16622 && (w
->column_number_displayed
!= current_column ())))
16623 /* This means that the window has a mode line. */
16624 && (WINDOW_WANTS_MODELINE_P (w
)
16625 || WINDOW_WANTS_HEADER_LINE_P (w
)))
16628 display_mode_lines (w
);
16630 /* If mode line height has changed, arrange for a thorough
16631 immediate redisplay using the correct mode line height. */
16632 if (WINDOW_WANTS_MODELINE_P (w
)
16633 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
16635 f
->fonts_changed
= 1;
16636 w
->mode_line_height
= -1;
16637 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
16638 = DESIRED_MODE_LINE_HEIGHT (w
);
16641 /* If header line height has changed, arrange for a thorough
16642 immediate redisplay using the correct header line height. */
16643 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16644 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
16646 f
->fonts_changed
= 1;
16647 w
->header_line_height
= -1;
16648 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
16649 = DESIRED_HEADER_LINE_HEIGHT (w
);
16652 if (f
->fonts_changed
)
16653 goto need_larger_matrices
;
16656 if (!line_number_displayed
&& w
->base_line_pos
!= -1)
16658 w
->base_line_pos
= 0;
16659 w
->base_line_number
= 0;
16664 /* When we reach a frame's selected window, redo the frame's menu bar. */
16665 if (update_mode_line
16666 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
16668 int redisplay_menu_p
= 0;
16670 if (FRAME_WINDOW_P (f
))
16672 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
16673 || defined (HAVE_NS) || defined (USE_GTK)
16674 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
16676 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16680 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16682 if (redisplay_menu_p
)
16683 display_menu_bar (w
);
16685 #ifdef HAVE_WINDOW_SYSTEM
16686 if (FRAME_WINDOW_P (f
))
16688 #if defined (USE_GTK) || defined (HAVE_NS)
16689 if (FRAME_EXTERNAL_TOOL_BAR (f
))
16690 redisplay_tool_bar (f
);
16692 if (WINDOWP (f
->tool_bar_window
)
16693 && (FRAME_TOOL_BAR_HEIGHT (f
) > 0
16694 || !NILP (Vauto_resize_tool_bars
))
16695 && redisplay_tool_bar (f
))
16696 ignore_mouse_drag_p
= 1;
16702 #ifdef HAVE_WINDOW_SYSTEM
16703 if (FRAME_WINDOW_P (f
)
16704 && update_window_fringes (w
, (just_this_one_p
16705 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
16706 || w
->pseudo_window_p
)))
16710 if (draw_window_fringes (w
, 1))
16712 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
16713 x_draw_right_divider (w
);
16715 x_draw_vertical_border (w
);
16721 if (WINDOW_BOTTOM_DIVIDER_WIDTH (w
))
16722 x_draw_bottom_divider (w
);
16723 #endif /* HAVE_WINDOW_SYSTEM */
16725 /* We go to this label, with fonts_changed set, if it is
16726 necessary to try again using larger glyph matrices.
16727 We have to redeem the scroll bar even in this case,
16728 because the loop in redisplay_internal expects that. */
16729 need_larger_matrices
:
16731 finish_scroll_bars
:
16733 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
16735 /* Set the thumb's position and size. */
16736 set_vertical_scroll_bar (w
);
16738 /* Note that we actually used the scroll bar attached to this
16739 window, so it shouldn't be deleted at the end of redisplay. */
16740 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
16741 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
16744 /* Restore current_buffer and value of point in it. The window
16745 update may have changed the buffer, so first make sure `opoint'
16746 is still valid (Bug#6177). */
16747 if (CHARPOS (opoint
) < BEGV
)
16748 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
16749 else if (CHARPOS (opoint
) > ZV
)
16750 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
16752 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
16754 set_buffer_internal_1 (old
);
16755 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
16756 shorter. This can be caused by log truncation in *Messages*. */
16757 if (CHARPOS (lpoint
) <= ZV
)
16758 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
16760 unbind_to (count
, Qnil
);
16764 /* Build the complete desired matrix of WINDOW with a window start
16765 buffer position POS.
16767 Value is 1 if successful. It is zero if fonts were loaded during
16768 redisplay which makes re-adjusting glyph matrices necessary, and -1
16769 if point would appear in the scroll margins.
16770 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
16771 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
16775 try_window (Lisp_Object window
, struct text_pos pos
, int flags
)
16777 struct window
*w
= XWINDOW (window
);
16779 struct glyph_row
*last_text_row
= NULL
;
16780 struct frame
*f
= XFRAME (w
->frame
);
16781 int frame_line_height
= default_line_pixel_height (w
);
16783 /* Make POS the new window start. */
16784 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
16786 /* Mark cursor position as unknown. No overlay arrow seen. */
16787 w
->cursor
.vpos
= -1;
16788 overlay_arrow_seen
= 0;
16790 /* Initialize iterator and info to start at POS. */
16791 start_display (&it
, w
, pos
);
16793 /* Display all lines of W. */
16794 while (it
.current_y
< it
.last_visible_y
)
16796 if (display_line (&it
))
16797 last_text_row
= it
.glyph_row
- 1;
16798 if (f
->fonts_changed
&& !(flags
& TRY_WINDOW_IGNORE_FONTS_CHANGE
))
16802 /* Don't let the cursor end in the scroll margins. */
16803 if ((flags
& TRY_WINDOW_CHECK_MARGINS
)
16804 && !MINI_WINDOW_P (w
))
16806 int this_scroll_margin
;
16807 int window_total_lines
16808 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (f
) / frame_line_height
;
16810 if (scroll_margin
> 0)
16812 this_scroll_margin
= min (scroll_margin
, window_total_lines
/ 4);
16813 this_scroll_margin
*= frame_line_height
;
16816 this_scroll_margin
= 0;
16818 if ((w
->cursor
.y
>= 0 /* not vscrolled */
16819 && w
->cursor
.y
< this_scroll_margin
16820 && CHARPOS (pos
) > BEGV
16821 && IT_CHARPOS (it
) < ZV
)
16822 /* rms: considering make_cursor_line_fully_visible_p here
16823 seems to give wrong results. We don't want to recenter
16824 when the last line is partly visible, we want to allow
16825 that case to be handled in the usual way. */
16826 || w
->cursor
.y
> it
.last_visible_y
- this_scroll_margin
- 1)
16828 w
->cursor
.vpos
= -1;
16829 clear_glyph_matrix (w
->desired_matrix
);
16834 /* If bottom moved off end of frame, change mode line percentage. */
16835 if (w
->window_end_pos
<= 0 && Z
!= IT_CHARPOS (it
))
16836 w
->update_mode_line
= 1;
16838 /* Set window_end_pos to the offset of the last character displayed
16839 on the window from the end of current_buffer. Set
16840 window_end_vpos to its row number. */
16843 eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
16844 adjust_window_ends (w
, last_text_row
, 0);
16846 (MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w
->desired_matrix
,
16847 w
->window_end_vpos
)));
16851 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
16852 w
->window_end_pos
= Z
- ZV
;
16853 w
->window_end_vpos
= 0;
16856 /* But that is not valid info until redisplay finishes. */
16857 w
->window_end_valid
= 0;
16863 /************************************************************************
16864 Window redisplay reusing current matrix when buffer has not changed
16865 ************************************************************************/
16867 /* Try redisplay of window W showing an unchanged buffer with a
16868 different window start than the last time it was displayed by
16869 reusing its current matrix. Value is non-zero if successful.
16870 W->start is the new window start. */
16873 try_window_reusing_current_matrix (struct window
*w
)
16875 struct frame
*f
= XFRAME (w
->frame
);
16876 struct glyph_row
*bottom_row
;
16879 struct text_pos start
, new_start
;
16880 int nrows_scrolled
, i
;
16881 struct glyph_row
*last_text_row
;
16882 struct glyph_row
*last_reused_text_row
;
16883 struct glyph_row
*start_row
;
16884 int start_vpos
, min_y
, max_y
;
16887 if (inhibit_try_window_reusing
)
16891 if (/* This function doesn't handle terminal frames. */
16892 !FRAME_WINDOW_P (f
)
16893 /* Don't try to reuse the display if windows have been split
16895 || windows_or_buffers_changed
16896 || f
->cursor_type_changed
)
16899 /* Can't do this if showing trailing whitespace. */
16900 if (!NILP (Vshow_trailing_whitespace
))
16903 /* If top-line visibility has changed, give up. */
16904 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16905 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
16908 /* Give up if old or new display is scrolled vertically. We could
16909 make this function handle this, but right now it doesn't. */
16910 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16911 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
16914 /* The variable new_start now holds the new window start. The old
16915 start `start' can be determined from the current matrix. */
16916 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
16917 start
= start_row
->minpos
;
16918 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16920 /* Clear the desired matrix for the display below. */
16921 clear_glyph_matrix (w
->desired_matrix
);
16923 if (CHARPOS (new_start
) <= CHARPOS (start
))
16925 /* Don't use this method if the display starts with an ellipsis
16926 displayed for invisible text. It's not easy to handle that case
16927 below, and it's certainly not worth the effort since this is
16928 not a frequent case. */
16929 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
16932 IF_DEBUG (debug_method_add (w
, "twu1"));
16934 /* Display up to a row that can be reused. The variable
16935 last_text_row is set to the last row displayed that displays
16936 text. Note that it.vpos == 0 if or if not there is a
16937 header-line; it's not the same as the MATRIX_ROW_VPOS! */
16938 start_display (&it
, w
, new_start
);
16939 w
->cursor
.vpos
= -1;
16940 last_text_row
= last_reused_text_row
= NULL
;
16942 while (it
.current_y
< it
.last_visible_y
&& !f
->fonts_changed
)
16944 /* If we have reached into the characters in the START row,
16945 that means the line boundaries have changed. So we
16946 can't start copying with the row START. Maybe it will
16947 work to start copying with the following row. */
16948 while (IT_CHARPOS (it
) > CHARPOS (start
))
16950 /* Advance to the next row as the "start". */
16952 start
= start_row
->minpos
;
16953 /* If there are no more rows to try, or just one, give up. */
16954 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
16955 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
16956 || CHARPOS (start
) == ZV
)
16958 clear_glyph_matrix (w
->desired_matrix
);
16962 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16964 /* If we have reached alignment, we can copy the rest of the
16966 if (IT_CHARPOS (it
) == CHARPOS (start
)
16967 /* Don't accept "alignment" inside a display vector,
16968 since start_row could have started in the middle of
16969 that same display vector (thus their character
16970 positions match), and we have no way of telling if
16971 that is the case. */
16972 && it
.current
.dpvec_index
< 0)
16975 if (display_line (&it
))
16976 last_text_row
= it
.glyph_row
- 1;
16980 /* A value of current_y < last_visible_y means that we stopped
16981 at the previous window start, which in turn means that we
16982 have at least one reusable row. */
16983 if (it
.current_y
< it
.last_visible_y
)
16985 struct glyph_row
*row
;
16987 /* IT.vpos always starts from 0; it counts text lines. */
16988 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
16990 /* Find PT if not already found in the lines displayed. */
16991 if (w
->cursor
.vpos
< 0)
16993 int dy
= it
.current_y
- start_row
->y
;
16995 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16996 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
16998 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
16999 dy
, nrows_scrolled
);
17002 clear_glyph_matrix (w
->desired_matrix
);
17007 /* Scroll the display. Do it before the current matrix is
17008 changed. The problem here is that update has not yet
17009 run, i.e. part of the current matrix is not up to date.
17010 scroll_run_hook will clear the cursor, and use the
17011 current matrix to get the height of the row the cursor is
17013 run
.current_y
= start_row
->y
;
17014 run
.desired_y
= it
.current_y
;
17015 run
.height
= it
.last_visible_y
- it
.current_y
;
17017 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
17020 FRAME_RIF (f
)->update_window_begin_hook (w
);
17021 FRAME_RIF (f
)->clear_window_mouse_face (w
);
17022 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
17023 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
17027 /* Shift current matrix down by nrows_scrolled lines. */
17028 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
17029 rotate_matrix (w
->current_matrix
,
17031 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
17034 /* Disable lines that must be updated. */
17035 for (i
= 0; i
< nrows_scrolled
; ++i
)
17036 (start_row
+ i
)->enabled_p
= false;
17038 /* Re-compute Y positions. */
17039 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
17040 max_y
= it
.last_visible_y
;
17041 for (row
= start_row
+ nrows_scrolled
;
17045 row
->y
= it
.current_y
;
17046 row
->visible_height
= row
->height
;
17048 if (row
->y
< min_y
)
17049 row
->visible_height
-= min_y
- row
->y
;
17050 if (row
->y
+ row
->height
> max_y
)
17051 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
17052 if (row
->fringe_bitmap_periodic_p
)
17053 row
->redraw_fringe_bitmaps_p
= 1;
17055 it
.current_y
+= row
->height
;
17057 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17058 last_reused_text_row
= row
;
17059 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
17063 /* Disable lines in the current matrix which are now
17064 below the window. */
17065 for (++row
; row
< bottom_row
; ++row
)
17066 row
->enabled_p
= row
->mode_line_p
= 0;
17069 /* Update window_end_pos etc.; last_reused_text_row is the last
17070 reused row from the current matrix containing text, if any.
17071 The value of last_text_row is the last displayed line
17072 containing text. */
17073 if (last_reused_text_row
)
17074 adjust_window_ends (w
, last_reused_text_row
, 1);
17075 else if (last_text_row
)
17076 adjust_window_ends (w
, last_text_row
, 0);
17079 /* This window must be completely empty. */
17080 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
17081 w
->window_end_pos
= Z
- ZV
;
17082 w
->window_end_vpos
= 0;
17084 w
->window_end_valid
= 0;
17086 /* Update hint: don't try scrolling again in update_window. */
17087 w
->desired_matrix
->no_scrolling_p
= 1;
17090 debug_method_add (w
, "try_window_reusing_current_matrix 1");
17094 else if (CHARPOS (new_start
) > CHARPOS (start
))
17096 struct glyph_row
*pt_row
, *row
;
17097 struct glyph_row
*first_reusable_row
;
17098 struct glyph_row
*first_row_to_display
;
17100 int yb
= window_text_bottom_y (w
);
17102 /* Find the row starting at new_start, if there is one. Don't
17103 reuse a partially visible line at the end. */
17104 first_reusable_row
= start_row
;
17105 while (first_reusable_row
->enabled_p
17106 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
17107 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
17108 < CHARPOS (new_start
)))
17109 ++first_reusable_row
;
17111 /* Give up if there is no row to reuse. */
17112 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
17113 || !first_reusable_row
->enabled_p
17114 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
17115 != CHARPOS (new_start
)))
17118 /* We can reuse fully visible rows beginning with
17119 first_reusable_row to the end of the window. Set
17120 first_row_to_display to the first row that cannot be reused.
17121 Set pt_row to the row containing point, if there is any. */
17123 for (first_row_to_display
= first_reusable_row
;
17124 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
17125 ++first_row_to_display
)
17127 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
17128 && (PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
)
17129 || (PT
== MATRIX_ROW_END_CHARPOS (first_row_to_display
)
17130 && first_row_to_display
->ends_at_zv_p
17131 && pt_row
== NULL
)))
17132 pt_row
= first_row_to_display
;
17135 /* Start displaying at the start of first_row_to_display. */
17136 eassert (first_row_to_display
->y
< yb
);
17137 init_to_row_start (&it
, w
, first_row_to_display
);
17139 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
17141 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
17143 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
17144 + WINDOW_HEADER_LINE_HEIGHT (w
));
17146 /* Display lines beginning with first_row_to_display in the
17147 desired matrix. Set last_text_row to the last row displayed
17148 that displays text. */
17149 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
17150 if (pt_row
== NULL
)
17151 w
->cursor
.vpos
= -1;
17152 last_text_row
= NULL
;
17153 while (it
.current_y
< it
.last_visible_y
&& !f
->fonts_changed
)
17154 if (display_line (&it
))
17155 last_text_row
= it
.glyph_row
- 1;
17157 /* If point is in a reused row, adjust y and vpos of the cursor
17161 w
->cursor
.vpos
-= nrows_scrolled
;
17162 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
17165 /* Give up if point isn't in a row displayed or reused. (This
17166 also handles the case where w->cursor.vpos < nrows_scrolled
17167 after the calls to display_line, which can happen with scroll
17168 margins. See bug#1295.) */
17169 if (w
->cursor
.vpos
< 0)
17171 clear_glyph_matrix (w
->desired_matrix
);
17175 /* Scroll the display. */
17176 run
.current_y
= first_reusable_row
->y
;
17177 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
17178 run
.height
= it
.last_visible_y
- run
.current_y
;
17179 dy
= run
.current_y
- run
.desired_y
;
17184 FRAME_RIF (f
)->update_window_begin_hook (w
);
17185 FRAME_RIF (f
)->clear_window_mouse_face (w
);
17186 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
17187 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
17191 /* Adjust Y positions of reused rows. */
17192 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
17193 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
17194 max_y
= it
.last_visible_y
;
17195 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
17198 row
->visible_height
= row
->height
;
17199 if (row
->y
< min_y
)
17200 row
->visible_height
-= min_y
- row
->y
;
17201 if (row
->y
+ row
->height
> max_y
)
17202 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
17203 if (row
->fringe_bitmap_periodic_p
)
17204 row
->redraw_fringe_bitmaps_p
= 1;
17207 /* Scroll the current matrix. */
17208 eassert (nrows_scrolled
> 0);
17209 rotate_matrix (w
->current_matrix
,
17211 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
17214 /* Disable rows not reused. */
17215 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
17216 row
->enabled_p
= false;
17218 /* Point may have moved to a different line, so we cannot assume that
17219 the previous cursor position is valid; locate the correct row. */
17222 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
17224 && PT
>= MATRIX_ROW_END_CHARPOS (row
)
17225 && !row
->ends_at_zv_p
;
17229 w
->cursor
.y
= row
->y
;
17231 if (row
< bottom_row
)
17233 /* Can't simply scan the row for point with
17234 bidi-reordered glyph rows. Let set_cursor_from_row
17235 figure out where to put the cursor, and if it fails,
17237 if (!NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
)))
17239 if (!set_cursor_from_row (w
, row
, w
->current_matrix
,
17242 clear_glyph_matrix (w
->desired_matrix
);
17248 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
17249 struct glyph
*end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
17252 && (!BUFFERP (glyph
->object
)
17253 || glyph
->charpos
< PT
);
17257 w
->cursor
.x
+= glyph
->pixel_width
;
17263 /* Adjust window end. A null value of last_text_row means that
17264 the window end is in reused rows which in turn means that
17265 only its vpos can have changed. */
17267 adjust_window_ends (w
, last_text_row
, 0);
17269 w
->window_end_vpos
-= nrows_scrolled
;
17271 w
->window_end_valid
= 0;
17272 w
->desired_matrix
->no_scrolling_p
= 1;
17275 debug_method_add (w
, "try_window_reusing_current_matrix 2");
17285 /************************************************************************
17286 Window redisplay reusing current matrix when buffer has changed
17287 ************************************************************************/
17289 static struct glyph_row
*find_last_unchanged_at_beg_row (struct window
*);
17290 static struct glyph_row
*find_first_unchanged_at_end_row (struct window
*,
17291 ptrdiff_t *, ptrdiff_t *);
17292 static struct glyph_row
*
17293 find_last_row_displaying_text (struct glyph_matrix
*, struct it
*,
17294 struct glyph_row
*);
17297 /* Return the last row in MATRIX displaying text. If row START is
17298 non-null, start searching with that row. IT gives the dimensions
17299 of the display. Value is null if matrix is empty; otherwise it is
17300 a pointer to the row found. */
17302 static struct glyph_row
*
17303 find_last_row_displaying_text (struct glyph_matrix
*matrix
, struct it
*it
,
17304 struct glyph_row
*start
)
17306 struct glyph_row
*row
, *row_found
;
17308 /* Set row_found to the last row in IT->w's current matrix
17309 displaying text. The loop looks funny but think of partially
17312 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
17313 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17315 eassert (row
->enabled_p
);
17317 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
17326 /* Return the last row in the current matrix of W that is not affected
17327 by changes at the start of current_buffer that occurred since W's
17328 current matrix was built. Value is null if no such row exists.
17330 BEG_UNCHANGED us the number of characters unchanged at the start of
17331 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
17332 first changed character in current_buffer. Characters at positions <
17333 BEG + BEG_UNCHANGED are at the same buffer positions as they were
17334 when the current matrix was built. */
17336 static struct glyph_row
*
17337 find_last_unchanged_at_beg_row (struct window
*w
)
17339 ptrdiff_t first_changed_pos
= BEG
+ BEG_UNCHANGED
;
17340 struct glyph_row
*row
;
17341 struct glyph_row
*row_found
= NULL
;
17342 int yb
= window_text_bottom_y (w
);
17344 /* Find the last row displaying unchanged text. */
17345 for (row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
17346 MATRIX_ROW_DISPLAYS_TEXT_P (row
)
17347 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
;
17350 if (/* If row ends before first_changed_pos, it is unchanged,
17351 except in some case. */
17352 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
17353 /* When row ends in ZV and we write at ZV it is not
17355 && !row
->ends_at_zv_p
17356 /* When first_changed_pos is the end of a continued line,
17357 row is not unchanged because it may be no longer
17359 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
17360 && (row
->continued_p
17361 || row
->exact_window_width_line_p
))
17362 /* If ROW->end is beyond ZV, then ROW->end is outdated and
17363 needs to be recomputed, so don't consider this row as
17364 unchanged. This happens when the last line was
17365 bidi-reordered and was killed immediately before this
17366 redisplay cycle. In that case, ROW->end stores the
17367 buffer position of the first visual-order character of
17368 the killed text, which is now beyond ZV. */
17369 && CHARPOS (row
->end
.pos
) <= ZV
)
17372 /* Stop if last visible row. */
17373 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
17381 /* Find the first glyph row in the current matrix of W that is not
17382 affected by changes at the end of current_buffer since the
17383 time W's current matrix was built.
17385 Return in *DELTA the number of chars by which buffer positions in
17386 unchanged text at the end of current_buffer must be adjusted.
17388 Return in *DELTA_BYTES the corresponding number of bytes.
17390 Value is null if no such row exists, i.e. all rows are affected by
17393 static struct glyph_row
*
17394 find_first_unchanged_at_end_row (struct window
*w
,
17395 ptrdiff_t *delta
, ptrdiff_t *delta_bytes
)
17397 struct glyph_row
*row
;
17398 struct glyph_row
*row_found
= NULL
;
17400 *delta
= *delta_bytes
= 0;
17402 /* Display must not have been paused, otherwise the current matrix
17403 is not up to date. */
17404 eassert (w
->window_end_valid
);
17406 /* A value of window_end_pos >= END_UNCHANGED means that the window
17407 end is in the range of changed text. If so, there is no
17408 unchanged row at the end of W's current matrix. */
17409 if (w
->window_end_pos
>= END_UNCHANGED
)
17412 /* Set row to the last row in W's current matrix displaying text. */
17413 row
= MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
);
17415 /* If matrix is entirely empty, no unchanged row exists. */
17416 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17418 /* The value of row is the last glyph row in the matrix having a
17419 meaningful buffer position in it. The end position of row
17420 corresponds to window_end_pos. This allows us to translate
17421 buffer positions in the current matrix to current buffer
17422 positions for characters not in changed text. */
17424 MATRIX_ROW_END_CHARPOS (row
) + w
->window_end_pos
;
17425 ptrdiff_t Z_BYTE_old
=
17426 MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17427 ptrdiff_t last_unchanged_pos
, last_unchanged_pos_old
;
17428 struct glyph_row
*first_text_row
17429 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
17431 *delta
= Z
- Z_old
;
17432 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17434 /* Set last_unchanged_pos to the buffer position of the last
17435 character in the buffer that has not been changed. Z is the
17436 index + 1 of the last character in current_buffer, i.e. by
17437 subtracting END_UNCHANGED we get the index of the last
17438 unchanged character, and we have to add BEG to get its buffer
17440 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
17441 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
17443 /* Search backward from ROW for a row displaying a line that
17444 starts at a minimum position >= last_unchanged_pos_old. */
17445 for (; row
> first_text_row
; --row
)
17447 /* This used to abort, but it can happen.
17448 It is ok to just stop the search instead here. KFS. */
17449 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17452 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
17457 eassert (!row_found
|| MATRIX_ROW_DISPLAYS_TEXT_P (row_found
));
17463 /* Make sure that glyph rows in the current matrix of window W
17464 reference the same glyph memory as corresponding rows in the
17465 frame's frame matrix. This function is called after scrolling W's
17466 current matrix on a terminal frame in try_window_id and
17467 try_window_reusing_current_matrix. */
17470 sync_frame_with_window_matrix_rows (struct window
*w
)
17472 struct frame
*f
= XFRAME (w
->frame
);
17473 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
17475 /* Preconditions: W must be a leaf window and full-width. Its frame
17476 must have a frame matrix. */
17477 eassert (BUFFERP (w
->contents
));
17478 eassert (WINDOW_FULL_WIDTH_P (w
));
17479 eassert (!FRAME_WINDOW_P (f
));
17481 /* If W is a full-width window, glyph pointers in W's current matrix
17482 have, by definition, to be the same as glyph pointers in the
17483 corresponding frame matrix. Note that frame matrices have no
17484 marginal areas (see build_frame_matrix). */
17485 window_row
= w
->current_matrix
->rows
;
17486 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
17487 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
17488 while (window_row
< window_row_end
)
17490 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
17491 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
17493 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
17494 frame_row
->glyphs
[TEXT_AREA
] = start
;
17495 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
17496 frame_row
->glyphs
[LAST_AREA
] = end
;
17498 /* Disable frame rows whose corresponding window rows have
17499 been disabled in try_window_id. */
17500 if (!window_row
->enabled_p
)
17501 frame_row
->enabled_p
= false;
17503 ++window_row
, ++frame_row
;
17508 /* Find the glyph row in window W containing CHARPOS. Consider all
17509 rows between START and END (not inclusive). END null means search
17510 all rows to the end of the display area of W. Value is the row
17511 containing CHARPOS or null. */
17514 row_containing_pos (struct window
*w
, ptrdiff_t charpos
,
17515 struct glyph_row
*start
, struct glyph_row
*end
, int dy
)
17517 struct glyph_row
*row
= start
;
17518 struct glyph_row
*best_row
= NULL
;
17519 ptrdiff_t mindif
= BUF_ZV (XBUFFER (w
->contents
)) + 1;
17522 /* If we happen to start on a header-line, skip that. */
17523 if (row
->mode_line_p
)
17526 if ((end
&& row
>= end
) || !row
->enabled_p
)
17529 last_y
= window_text_bottom_y (w
) - dy
;
17533 /* Give up if we have gone too far. */
17534 if (end
&& row
>= end
)
17536 /* This formerly returned if they were equal.
17537 I think that both quantities are of a "last plus one" type;
17538 if so, when they are equal, the row is within the screen. -- rms. */
17539 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
17542 /* If it is in this row, return this row. */
17543 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
17544 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
17545 /* The end position of a row equals the start
17546 position of the next row. If CHARPOS is there, we
17547 would rather consider it displayed in the next
17548 line, except when this line ends in ZV. */
17549 && !row_for_charpos_p (row
, charpos
)))
17550 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
17554 if (NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
))
17555 || (!best_row
&& !row
->continued_p
))
17557 /* In bidi-reordered rows, there could be several rows whose
17558 edges surround CHARPOS, all of these rows belonging to
17559 the same continued line. We need to find the row which
17560 fits CHARPOS the best. */
17561 for (g
= row
->glyphs
[TEXT_AREA
];
17562 g
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
17565 if (!STRINGP (g
->object
))
17567 if (g
->charpos
> 0 && eabs (g
->charpos
- charpos
) < mindif
)
17569 mindif
= eabs (g
->charpos
- charpos
);
17571 /* Exact match always wins. */
17578 else if (best_row
&& !row
->continued_p
)
17585 /* Try to redisplay window W by reusing its existing display. W's
17586 current matrix must be up to date when this function is called,
17587 i.e. window_end_valid must be nonzero.
17591 >= 1 if successful, i.e. display has been updated
17593 1 means the changes were in front of a newline that precedes
17594 the window start, and the whole current matrix was reused
17595 2 means the changes were after the last position displayed
17596 in the window, and the whole current matrix was reused
17597 3 means portions of the current matrix were reused, while
17598 some of the screen lines were redrawn
17599 -1 if redisplay with same window start is known not to succeed
17600 0 if otherwise unsuccessful
17602 The following steps are performed:
17604 1. Find the last row in the current matrix of W that is not
17605 affected by changes at the start of current_buffer. If no such row
17608 2. Find the first row in W's current matrix that is not affected by
17609 changes at the end of current_buffer. Maybe there is no such row.
17611 3. Display lines beginning with the row + 1 found in step 1 to the
17612 row found in step 2 or, if step 2 didn't find a row, to the end of
17615 4. If cursor is not known to appear on the window, give up.
17617 5. If display stopped at the row found in step 2, scroll the
17618 display and current matrix as needed.
17620 6. Maybe display some lines at the end of W, if we must. This can
17621 happen under various circumstances, like a partially visible line
17622 becoming fully visible, or because newly displayed lines are displayed
17623 in smaller font sizes.
17625 7. Update W's window end information. */
17628 try_window_id (struct window
*w
)
17630 struct frame
*f
= XFRAME (w
->frame
);
17631 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
17632 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
17633 struct glyph_row
*last_unchanged_at_beg_row
;
17634 struct glyph_row
*first_unchanged_at_end_row
;
17635 struct glyph_row
*row
;
17636 struct glyph_row
*bottom_row
;
17639 ptrdiff_t delta
= 0, delta_bytes
= 0, stop_pos
;
17641 struct text_pos start_pos
;
17643 int first_unchanged_at_end_vpos
= 0;
17644 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
17645 struct text_pos start
;
17646 ptrdiff_t first_changed_charpos
, last_changed_charpos
;
17649 if (inhibit_try_window_id
)
17653 /* This is handy for debugging. */
17655 #define GIVE_UP(X) \
17657 fprintf (stderr, "try_window_id give up %d\n", (X)); \
17661 #define GIVE_UP(X) return 0
17664 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
17666 /* Don't use this for mini-windows because these can show
17667 messages and mini-buffers, and we don't handle that here. */
17668 if (MINI_WINDOW_P (w
))
17671 /* This flag is used to prevent redisplay optimizations. */
17672 if (windows_or_buffers_changed
|| f
->cursor_type_changed
)
17675 /* This function's optimizations cannot be used if overlays have
17676 changed in the buffer displayed by the window, so give up if they
17678 if (w
->last_overlay_modified
!= OVERLAY_MODIFF
)
17681 /* Verify that narrowing has not changed.
17682 Also verify that we were not told to prevent redisplay optimizations.
17683 It would be nice to further
17684 reduce the number of cases where this prevents try_window_id. */
17685 if (current_buffer
->clip_changed
17686 || current_buffer
->prevent_redisplay_optimizations_p
)
17689 /* Window must either use window-based redisplay or be full width. */
17690 if (!FRAME_WINDOW_P (f
)
17691 && (!FRAME_LINE_INS_DEL_OK (f
)
17692 || !WINDOW_FULL_WIDTH_P (w
)))
17695 /* Give up if point is known NOT to appear in W. */
17696 if (PT
< CHARPOS (start
))
17699 /* Another way to prevent redisplay optimizations. */
17700 if (w
->last_modified
== 0)
17703 /* Verify that window is not hscrolled. */
17704 if (w
->hscroll
!= 0)
17707 /* Verify that display wasn't paused. */
17708 if (!w
->window_end_valid
)
17711 /* Likewise if highlighting trailing whitespace. */
17712 if (!NILP (Vshow_trailing_whitespace
))
17715 /* Can't use this if overlay arrow position and/or string have
17717 if (overlay_arrows_changed_p ())
17720 /* When word-wrap is on, adding a space to the first word of a
17721 wrapped line can change the wrap position, altering the line
17722 above it. It might be worthwhile to handle this more
17723 intelligently, but for now just redisplay from scratch. */
17724 if (!NILP (BVAR (XBUFFER (w
->contents
), word_wrap
)))
17727 /* Under bidi reordering, adding or deleting a character in the
17728 beginning of a paragraph, before the first strong directional
17729 character, can change the base direction of the paragraph (unless
17730 the buffer specifies a fixed paragraph direction), which will
17731 require to redisplay the whole paragraph. It might be worthwhile
17732 to find the paragraph limits and widen the range of redisplayed
17733 lines to that, but for now just give up this optimization and
17734 redisplay from scratch. */
17735 if (!NILP (BVAR (XBUFFER (w
->contents
), bidi_display_reordering
))
17736 && NILP (BVAR (XBUFFER (w
->contents
), bidi_paragraph_direction
)))
17739 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
17740 only if buffer has really changed. The reason is that the gap is
17741 initially at Z for freshly visited files. The code below would
17742 set end_unchanged to 0 in that case. */
17743 if (MODIFF
> SAVE_MODIFF
17744 /* This seems to happen sometimes after saving a buffer. */
17745 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
17747 if (GPT
- BEG
< BEG_UNCHANGED
)
17748 BEG_UNCHANGED
= GPT
- BEG
;
17749 if (Z
- GPT
< END_UNCHANGED
)
17750 END_UNCHANGED
= Z
- GPT
;
17753 /* The position of the first and last character that has been changed. */
17754 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
17755 last_changed_charpos
= Z
- END_UNCHANGED
;
17757 /* If window starts after a line end, and the last change is in
17758 front of that newline, then changes don't affect the display.
17759 This case happens with stealth-fontification. Note that although
17760 the display is unchanged, glyph positions in the matrix have to
17761 be adjusted, of course. */
17762 row
= MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
);
17763 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
17764 && ((last_changed_charpos
< CHARPOS (start
)
17765 && CHARPOS (start
) == BEGV
)
17766 || (last_changed_charpos
< CHARPOS (start
) - 1
17767 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
17769 ptrdiff_t Z_old
, Z_delta
, Z_BYTE_old
, Z_delta_bytes
;
17770 struct glyph_row
*r0
;
17772 /* Compute how many chars/bytes have been added to or removed
17773 from the buffer. */
17774 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + w
->window_end_pos
;
17775 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17776 Z_delta
= Z
- Z_old
;
17777 Z_delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17779 /* Give up if PT is not in the window. Note that it already has
17780 been checked at the start of try_window_id that PT is not in
17781 front of the window start. */
17782 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + Z_delta
)
17785 /* If window start is unchanged, we can reuse the whole matrix
17786 as is, after adjusting glyph positions. No need to compute
17787 the window end again, since its offset from Z hasn't changed. */
17788 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17789 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + Z_delta
17790 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + Z_delta_bytes
17791 /* PT must not be in a partially visible line. */
17792 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + Z_delta
17793 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17795 /* Adjust positions in the glyph matrix. */
17796 if (Z_delta
|| Z_delta_bytes
)
17798 struct glyph_row
*r1
17799 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
17800 increment_matrix_positions (w
->current_matrix
,
17801 MATRIX_ROW_VPOS (r0
, current_matrix
),
17802 MATRIX_ROW_VPOS (r1
, current_matrix
),
17803 Z_delta
, Z_delta_bytes
);
17806 /* Set the cursor. */
17807 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17809 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17814 /* Handle the case that changes are all below what is displayed in
17815 the window, and that PT is in the window. This shortcut cannot
17816 be taken if ZV is visible in the window, and text has been added
17817 there that is visible in the window. */
17818 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
17819 /* ZV is not visible in the window, or there are no
17820 changes at ZV, actually. */
17821 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
17822 || first_changed_charpos
== last_changed_charpos
))
17824 struct glyph_row
*r0
;
17826 /* Give up if PT is not in the window. Note that it already has
17827 been checked at the start of try_window_id that PT is not in
17828 front of the window start. */
17829 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
17832 /* If window start is unchanged, we can reuse the whole matrix
17833 as is, without changing glyph positions since no text has
17834 been added/removed in front of the window end. */
17835 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17836 if (TEXT_POS_EQUAL_P (start
, r0
->minpos
)
17837 /* PT must not be in a partially visible line. */
17838 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
17839 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17841 /* We have to compute the window end anew since text
17842 could have been added/removed after it. */
17843 w
->window_end_pos
= Z
- MATRIX_ROW_END_CHARPOS (row
);
17844 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17846 /* Set the cursor. */
17847 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17849 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17854 /* Give up if window start is in the changed area.
17856 The condition used to read
17858 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
17860 but why that was tested escapes me at the moment. */
17861 if (CHARPOS (start
) >= first_changed_charpos
17862 && CHARPOS (start
) <= last_changed_charpos
)
17865 /* Check that window start agrees with the start of the first glyph
17866 row in its current matrix. Check this after we know the window
17867 start is not in changed text, otherwise positions would not be
17869 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17870 if (!TEXT_POS_EQUAL_P (start
, row
->minpos
))
17873 /* Give up if the window ends in strings. Overlay strings
17874 at the end are difficult to handle, so don't try. */
17875 row
= MATRIX_ROW (current_matrix
, w
->window_end_vpos
);
17876 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
17879 /* Compute the position at which we have to start displaying new
17880 lines. Some of the lines at the top of the window might be
17881 reusable because they are not displaying changed text. Find the
17882 last row in W's current matrix not affected by changes at the
17883 start of current_buffer. Value is null if changes start in the
17884 first line of window. */
17885 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
17886 if (last_unchanged_at_beg_row
)
17888 /* Avoid starting to display in the middle of a character, a TAB
17889 for instance. This is easier than to set up the iterator
17890 exactly, and it's not a frequent case, so the additional
17891 effort wouldn't really pay off. */
17892 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
17893 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
17894 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
17895 --last_unchanged_at_beg_row
;
17897 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
17900 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
17902 start_pos
= it
.current
.pos
;
17904 /* Start displaying new lines in the desired matrix at the same
17905 vpos we would use in the current matrix, i.e. below
17906 last_unchanged_at_beg_row. */
17907 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
17909 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
17910 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
17912 eassert (it
.hpos
== 0 && it
.current_x
== 0);
17916 /* There are no reusable lines at the start of the window.
17917 Start displaying in the first text line. */
17918 start_display (&it
, w
, start
);
17919 it
.vpos
= it
.first_vpos
;
17920 start_pos
= it
.current
.pos
;
17923 /* Find the first row that is not affected by changes at the end of
17924 the buffer. Value will be null if there is no unchanged row, in
17925 which case we must redisplay to the end of the window. delta
17926 will be set to the value by which buffer positions beginning with
17927 first_unchanged_at_end_row have to be adjusted due to text
17929 first_unchanged_at_end_row
17930 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
17931 IF_DEBUG (debug_delta
= delta
);
17932 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
17934 /* Set stop_pos to the buffer position up to which we will have to
17935 display new lines. If first_unchanged_at_end_row != NULL, this
17936 is the buffer position of the start of the line displayed in that
17937 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
17938 that we don't stop at a buffer position. */
17940 if (first_unchanged_at_end_row
)
17942 eassert (last_unchanged_at_beg_row
== NULL
17943 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
17945 /* If this is a continuation line, move forward to the next one
17946 that isn't. Changes in lines above affect this line.
17947 Caution: this may move first_unchanged_at_end_row to a row
17948 not displaying text. */
17949 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
17950 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17951 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17952 < it
.last_visible_y
))
17953 ++first_unchanged_at_end_row
;
17955 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17956 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17957 >= it
.last_visible_y
))
17958 first_unchanged_at_end_row
= NULL
;
17961 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
17963 first_unchanged_at_end_vpos
17964 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
17965 eassert (stop_pos
>= Z
- END_UNCHANGED
);
17968 else if (last_unchanged_at_beg_row
== NULL
)
17974 /* Either there is no unchanged row at the end, or the one we have
17975 now displays text. This is a necessary condition for the window
17976 end pos calculation at the end of this function. */
17977 eassert (first_unchanged_at_end_row
== NULL
17978 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
17980 debug_last_unchanged_at_beg_vpos
17981 = (last_unchanged_at_beg_row
17982 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
17984 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
17986 #endif /* GLYPH_DEBUG */
17989 /* Display new lines. Set last_text_row to the last new line
17990 displayed which has text on it, i.e. might end up as being the
17991 line where the window_end_vpos is. */
17992 w
->cursor
.vpos
= -1;
17993 last_text_row
= NULL
;
17994 overlay_arrow_seen
= 0;
17995 while (it
.current_y
< it
.last_visible_y
17996 && !f
->fonts_changed
17997 && (first_unchanged_at_end_row
== NULL
17998 || IT_CHARPOS (it
) < stop_pos
))
18000 if (display_line (&it
))
18001 last_text_row
= it
.glyph_row
- 1;
18004 if (f
->fonts_changed
)
18008 /* Compute differences in buffer positions, y-positions etc. for
18009 lines reused at the bottom of the window. Compute what we can
18011 if (first_unchanged_at_end_row
18012 /* No lines reused because we displayed everything up to the
18013 bottom of the window. */
18014 && it
.current_y
< it
.last_visible_y
)
18017 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
18019 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
18020 run
.current_y
= first_unchanged_at_end_row
->y
;
18021 run
.desired_y
= run
.current_y
+ dy
;
18022 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
18026 delta
= delta_bytes
= dvpos
= dy
18027 = run
.current_y
= run
.desired_y
= run
.height
= 0;
18028 first_unchanged_at_end_row
= NULL
;
18030 IF_DEBUG ((debug_dvpos
= dvpos
, debug_dy
= dy
));
18033 /* Find the cursor if not already found. We have to decide whether
18034 PT will appear on this window (it sometimes doesn't, but this is
18035 not a very frequent case.) This decision has to be made before
18036 the current matrix is altered. A value of cursor.vpos < 0 means
18037 that PT is either in one of the lines beginning at
18038 first_unchanged_at_end_row or below the window. Don't care for
18039 lines that might be displayed later at the window end; as
18040 mentioned, this is not a frequent case. */
18041 if (w
->cursor
.vpos
< 0)
18043 /* Cursor in unchanged rows at the top? */
18044 if (PT
< CHARPOS (start_pos
)
18045 && last_unchanged_at_beg_row
)
18047 row
= row_containing_pos (w
, PT
,
18048 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
18049 last_unchanged_at_beg_row
+ 1, 0);
18051 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
18054 /* Start from first_unchanged_at_end_row looking for PT. */
18055 else if (first_unchanged_at_end_row
)
18057 row
= row_containing_pos (w
, PT
- delta
,
18058 first_unchanged_at_end_row
, NULL
, 0);
18060 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
18061 delta_bytes
, dy
, dvpos
);
18064 /* Give up if cursor was not found. */
18065 if (w
->cursor
.vpos
< 0)
18067 clear_glyph_matrix (w
->desired_matrix
);
18072 /* Don't let the cursor end in the scroll margins. */
18074 int this_scroll_margin
, cursor_height
;
18075 int frame_line_height
= default_line_pixel_height (w
);
18076 int window_total_lines
18077 = WINDOW_TOTAL_LINES (w
) * FRAME_LINE_HEIGHT (it
.f
) / frame_line_height
;
18079 this_scroll_margin
=
18080 max (0, min (scroll_margin
, window_total_lines
/ 4));
18081 this_scroll_margin
*= frame_line_height
;
18082 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
18084 if ((w
->cursor
.y
< this_scroll_margin
18085 && CHARPOS (start
) > BEGV
)
18086 /* Old redisplay didn't take scroll margin into account at the bottom,
18087 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
18088 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
18089 ? cursor_height
+ this_scroll_margin
18090 : 1)) > it
.last_visible_y
)
18092 w
->cursor
.vpos
= -1;
18093 clear_glyph_matrix (w
->desired_matrix
);
18098 /* Scroll the display. Do it before changing the current matrix so
18099 that xterm.c doesn't get confused about where the cursor glyph is
18101 if (dy
&& run
.height
)
18105 if (FRAME_WINDOW_P (f
))
18107 FRAME_RIF (f
)->update_window_begin_hook (w
);
18108 FRAME_RIF (f
)->clear_window_mouse_face (w
);
18109 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
18110 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
18114 /* Terminal frame. In this case, dvpos gives the number of
18115 lines to scroll by; dvpos < 0 means scroll up. */
18117 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
18118 int from
= WINDOW_TOP_EDGE_LINE (w
) + from_vpos
;
18119 int end
= (WINDOW_TOP_EDGE_LINE (w
)
18120 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
18121 + window_internal_height (w
));
18123 #if defined (HAVE_GPM) || defined (MSDOS)
18124 x_clear_window_mouse_face (w
);
18126 /* Perform the operation on the screen. */
18129 /* Scroll last_unchanged_at_beg_row to the end of the
18130 window down dvpos lines. */
18131 set_terminal_window (f
, end
);
18133 /* On dumb terminals delete dvpos lines at the end
18134 before inserting dvpos empty lines. */
18135 if (!FRAME_SCROLL_REGION_OK (f
))
18136 ins_del_lines (f
, end
- dvpos
, -dvpos
);
18138 /* Insert dvpos empty lines in front of
18139 last_unchanged_at_beg_row. */
18140 ins_del_lines (f
, from
, dvpos
);
18142 else if (dvpos
< 0)
18144 /* Scroll up last_unchanged_at_beg_vpos to the end of
18145 the window to last_unchanged_at_beg_vpos - |dvpos|. */
18146 set_terminal_window (f
, end
);
18148 /* Delete dvpos lines in front of
18149 last_unchanged_at_beg_vpos. ins_del_lines will set
18150 the cursor to the given vpos and emit |dvpos| delete
18152 ins_del_lines (f
, from
+ dvpos
, dvpos
);
18154 /* On a dumb terminal insert dvpos empty lines at the
18156 if (!FRAME_SCROLL_REGION_OK (f
))
18157 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
18160 set_terminal_window (f
, 0);
18166 /* Shift reused rows of the current matrix to the right position.
18167 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
18169 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
18170 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
18173 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
18174 bottom_vpos
, dvpos
);
18175 clear_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
18178 else if (dvpos
> 0)
18180 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
18181 bottom_vpos
, dvpos
);
18182 clear_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
18183 first_unchanged_at_end_vpos
+ dvpos
);
18186 /* For frame-based redisplay, make sure that current frame and window
18187 matrix are in sync with respect to glyph memory. */
18188 if (!FRAME_WINDOW_P (f
))
18189 sync_frame_with_window_matrix_rows (w
);
18191 /* Adjust buffer positions in reused rows. */
18192 if (delta
|| delta_bytes
)
18193 increment_matrix_positions (current_matrix
,
18194 first_unchanged_at_end_vpos
+ dvpos
,
18195 bottom_vpos
, delta
, delta_bytes
);
18197 /* Adjust Y positions. */
18199 shift_glyph_matrix (w
, current_matrix
,
18200 first_unchanged_at_end_vpos
+ dvpos
,
18203 if (first_unchanged_at_end_row
)
18205 first_unchanged_at_end_row
+= dvpos
;
18206 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
18207 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
18208 first_unchanged_at_end_row
= NULL
;
18211 /* If scrolling up, there may be some lines to display at the end of
18213 last_text_row_at_end
= NULL
;
18216 /* Scrolling up can leave for example a partially visible line
18217 at the end of the window to be redisplayed. */
18218 /* Set last_row to the glyph row in the current matrix where the
18219 window end line is found. It has been moved up or down in
18220 the matrix by dvpos. */
18221 int last_vpos
= w
->window_end_vpos
+ dvpos
;
18222 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
18224 /* If last_row is the window end line, it should display text. */
18225 eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_row
));
18227 /* If window end line was partially visible before, begin
18228 displaying at that line. Otherwise begin displaying with the
18229 line following it. */
18230 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
18232 init_to_row_start (&it
, w
, last_row
);
18233 it
.vpos
= last_vpos
;
18234 it
.current_y
= last_row
->y
;
18238 init_to_row_end (&it
, w
, last_row
);
18239 it
.vpos
= 1 + last_vpos
;
18240 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
18244 /* We may start in a continuation line. If so, we have to
18245 get the right continuation_lines_width and current_x. */
18246 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
18247 it
.hpos
= it
.current_x
= 0;
18249 /* Display the rest of the lines at the window end. */
18250 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
18251 while (it
.current_y
< it
.last_visible_y
&& !f
->fonts_changed
)
18253 /* Is it always sure that the display agrees with lines in
18254 the current matrix? I don't think so, so we mark rows
18255 displayed invalid in the current matrix by setting their
18256 enabled_p flag to zero. */
18257 SET_MATRIX_ROW_ENABLED_P (w
->current_matrix
, it
.vpos
, false);
18258 if (display_line (&it
))
18259 last_text_row_at_end
= it
.glyph_row
- 1;
18263 /* Update window_end_pos and window_end_vpos. */
18264 if (first_unchanged_at_end_row
&& !last_text_row_at_end
)
18266 /* Window end line if one of the preserved rows from the current
18267 matrix. Set row to the last row displaying text in current
18268 matrix starting at first_unchanged_at_end_row, after
18270 eassert (MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
18271 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
18272 first_unchanged_at_end_row
);
18273 eassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
18274 adjust_window_ends (w
, row
, 1);
18275 eassert (w
->window_end_bytepos
>= 0);
18276 IF_DEBUG (debug_method_add (w
, "A"));
18278 else if (last_text_row_at_end
)
18280 adjust_window_ends (w
, last_text_row_at_end
, 0);
18281 eassert (w
->window_end_bytepos
>= 0);
18282 IF_DEBUG (debug_method_add (w
, "B"));
18284 else if (last_text_row
)
18286 /* We have displayed either to the end of the window or at the
18287 end of the window, i.e. the last row with text is to be found
18288 in the desired matrix. */
18289 adjust_window_ends (w
, last_text_row
, 0);
18290 eassert (w
->window_end_bytepos
>= 0);
18292 else if (first_unchanged_at_end_row
== NULL
18293 && last_text_row
== NULL
18294 && last_text_row_at_end
== NULL
)
18296 /* Displayed to end of window, but no line containing text was
18297 displayed. Lines were deleted at the end of the window. */
18298 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
18299 int vpos
= w
->window_end_vpos
;
18300 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
18301 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
18304 row
== NULL
&& vpos
>= first_vpos
;
18305 --vpos
, --current_row
, --desired_row
)
18307 if (desired_row
->enabled_p
)
18309 if (MATRIX_ROW_DISPLAYS_TEXT_P (desired_row
))
18312 else if (MATRIX_ROW_DISPLAYS_TEXT_P (current_row
))
18316 eassert (row
!= NULL
);
18317 w
->window_end_vpos
= vpos
+ 1;
18318 w
->window_end_pos
= Z
- MATRIX_ROW_END_CHARPOS (row
);
18319 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
18320 eassert (w
->window_end_bytepos
>= 0);
18321 IF_DEBUG (debug_method_add (w
, "C"));
18326 IF_DEBUG ((debug_end_pos
= w
->window_end_pos
,
18327 debug_end_vpos
= w
->window_end_vpos
));
18329 /* Record that display has not been completed. */
18330 w
->window_end_valid
= 0;
18331 w
->desired_matrix
->no_scrolling_p
= 1;
18339 /***********************************************************************
18340 More debugging support
18341 ***********************************************************************/
18345 void dump_glyph_row (struct glyph_row
*, int, int) EXTERNALLY_VISIBLE
;
18346 void dump_glyph_matrix (struct glyph_matrix
*, int) EXTERNALLY_VISIBLE
;
18347 void dump_glyph (struct glyph_row
*, struct glyph
*, int) EXTERNALLY_VISIBLE
;
18350 /* Dump the contents of glyph matrix MATRIX on stderr.
18352 GLYPHS 0 means don't show glyph contents.
18353 GLYPHS 1 means show glyphs in short form
18354 GLYPHS > 1 means show glyphs in long form. */
18357 dump_glyph_matrix (struct glyph_matrix
*matrix
, int glyphs
)
18360 for (i
= 0; i
< matrix
->nrows
; ++i
)
18361 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
18365 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
18366 the glyph row and area where the glyph comes from. */
18369 dump_glyph (struct glyph_row
*row
, struct glyph
*glyph
, int area
)
18371 if (glyph
->type
== CHAR_GLYPH
18372 || glyph
->type
== GLYPHLESS_GLYPH
)
18375 " %5"pD
"d %c %9"pI
"d %c %3d 0x%06x %c %4d %1.1d%1.1d\n",
18376 glyph
- row
->glyphs
[TEXT_AREA
],
18377 (glyph
->type
== CHAR_GLYPH
18381 (BUFFERP (glyph
->object
)
18383 : (STRINGP (glyph
->object
)
18385 : (INTEGERP (glyph
->object
)
18388 glyph
->pixel_width
,
18390 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
18394 glyph
->left_box_line_p
,
18395 glyph
->right_box_line_p
);
18397 else if (glyph
->type
== STRETCH_GLYPH
)
18400 " %5"pD
"d %c %9"pI
"d %c %3d 0x%06x %c %4d %1.1d%1.1d\n",
18401 glyph
- row
->glyphs
[TEXT_AREA
],
18404 (BUFFERP (glyph
->object
)
18406 : (STRINGP (glyph
->object
)
18408 : (INTEGERP (glyph
->object
)
18411 glyph
->pixel_width
,
18415 glyph
->left_box_line_p
,
18416 glyph
->right_box_line_p
);
18418 else if (glyph
->type
== IMAGE_GLYPH
)
18421 " %5"pD
"d %c %9"pI
"d %c %3d 0x%06x %c %4d %1.1d%1.1d\n",
18422 glyph
- row
->glyphs
[TEXT_AREA
],
18425 (BUFFERP (glyph
->object
)
18427 : (STRINGP (glyph
->object
)
18429 : (INTEGERP (glyph
->object
)
18432 glyph
->pixel_width
,
18436 glyph
->left_box_line_p
,
18437 glyph
->right_box_line_p
);
18439 else if (glyph
->type
== COMPOSITE_GLYPH
)
18442 " %5"pD
"d %c %9"pI
"d %c %3d 0x%06x",
18443 glyph
- row
->glyphs
[TEXT_AREA
],
18446 (BUFFERP (glyph
->object
)
18448 : (STRINGP (glyph
->object
)
18450 : (INTEGERP (glyph
->object
)
18453 glyph
->pixel_width
,
18455 if (glyph
->u
.cmp
.automatic
)
18458 glyph
->slice
.cmp
.from
, glyph
->slice
.cmp
.to
);
18459 fprintf (stderr
, " . %4d %1.1d%1.1d\n",
18461 glyph
->left_box_line_p
,
18462 glyph
->right_box_line_p
);
18467 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
18468 GLYPHS 0 means don't show glyph contents.
18469 GLYPHS 1 means show glyphs in short form
18470 GLYPHS > 1 means show glyphs in long form. */
18473 dump_glyph_row (struct glyph_row
*row
, int vpos
, int glyphs
)
18477 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
18478 fprintf (stderr
, "==============================================================================\n");
18480 fprintf (stderr
, "%3d %9"pI
"d %9"pI
"d %4d %1.1d%1.1d%1.1d%1.1d\
18481 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
18483 MATRIX_ROW_START_CHARPOS (row
),
18484 MATRIX_ROW_END_CHARPOS (row
),
18485 row
->used
[TEXT_AREA
],
18486 row
->contains_overlapping_glyphs_p
,
18488 row
->truncated_on_left_p
,
18489 row
->truncated_on_right_p
,
18491 MATRIX_ROW_CONTINUATION_LINE_P (row
),
18492 MATRIX_ROW_DISPLAYS_TEXT_P (row
),
18495 row
->ends_in_middle_of_char_p
,
18496 row
->starts_in_middle_of_char_p
,
18502 row
->visible_height
,
18505 /* The next 3 lines should align to "Start" in the header. */
18506 fprintf (stderr
, " %9"pD
"d %9"pD
"d\t%5d\n", row
->start
.overlay_string_index
,
18507 row
->end
.overlay_string_index
,
18508 row
->continuation_lines_width
);
18509 fprintf (stderr
, " %9"pI
"d %9"pI
"d\n",
18510 CHARPOS (row
->start
.string_pos
),
18511 CHARPOS (row
->end
.string_pos
));
18512 fprintf (stderr
, " %9d %9d\n", row
->start
.dpvec_index
,
18513 row
->end
.dpvec_index
);
18520 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18522 struct glyph
*glyph
= row
->glyphs
[area
];
18523 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
18525 /* Glyph for a line end in text. */
18526 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
18529 if (glyph
< glyph_end
)
18530 fprintf (stderr
, " Glyph# Type Pos O W Code C Face LR\n");
18532 for (; glyph
< glyph_end
; ++glyph
)
18533 dump_glyph (row
, glyph
, area
);
18536 else if (glyphs
== 1)
18540 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18542 char *s
= alloca (row
->used
[area
] + 4);
18545 for (i
= 0; i
< row
->used
[area
]; ++i
)
18547 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
18548 if (i
== row
->used
[area
] - 1
18549 && area
== TEXT_AREA
18550 && INTEGERP (glyph
->object
)
18551 && glyph
->type
== CHAR_GLYPH
18552 && glyph
->u
.ch
== ' ')
18554 strcpy (&s
[i
], "[\\n]");
18557 else if (glyph
->type
== CHAR_GLYPH
18558 && glyph
->u
.ch
< 0x80
18559 && glyph
->u
.ch
>= ' ')
18560 s
[i
] = glyph
->u
.ch
;
18566 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
18572 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
18573 Sdump_glyph_matrix
, 0, 1, "p",
18574 doc
: /* Dump the current matrix of the selected window to stderr.
18575 Shows contents of glyph row structures. With non-nil
18576 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
18577 glyphs in short form, otherwise show glyphs in long form. */)
18578 (Lisp_Object glyphs
)
18580 struct window
*w
= XWINDOW (selected_window
);
18581 struct buffer
*buffer
= XBUFFER (w
->contents
);
18583 fprintf (stderr
, "PT = %"pI
"d, BEGV = %"pI
"d. ZV = %"pI
"d\n",
18584 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
18585 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
18586 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
18587 fprintf (stderr
, "=============================================\n");
18588 dump_glyph_matrix (w
->current_matrix
,
18589 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 0);
18594 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
18595 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
18598 struct frame
*f
= XFRAME (selected_frame
);
18599 dump_glyph_matrix (f
->current_matrix
, 1);
18604 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
18605 doc
: /* Dump glyph row ROW to stderr.
18606 GLYPH 0 means don't dump glyphs.
18607 GLYPH 1 means dump glyphs in short form.
18608 GLYPH > 1 or omitted means dump glyphs in long form. */)
18609 (Lisp_Object row
, Lisp_Object glyphs
)
18611 struct glyph_matrix
*matrix
;
18614 CHECK_NUMBER (row
);
18615 matrix
= XWINDOW (selected_window
)->current_matrix
;
18617 if (vpos
>= 0 && vpos
< matrix
->nrows
)
18618 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
18620 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18625 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
18626 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
18627 GLYPH 0 means don't dump glyphs.
18628 GLYPH 1 means dump glyphs in short form.
18629 GLYPH > 1 or omitted means dump glyphs in long form.
18631 If there's no tool-bar, or if the tool-bar is not drawn by Emacs,
18633 (Lisp_Object row
, Lisp_Object glyphs
)
18635 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
18636 struct frame
*sf
= SELECTED_FRAME ();
18637 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
18640 CHECK_NUMBER (row
);
18642 if (vpos
>= 0 && vpos
< m
->nrows
)
18643 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
18644 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18650 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
18651 doc
: /* Toggle tracing of redisplay.
18652 With ARG, turn tracing on if and only if ARG is positive. */)
18656 trace_redisplay_p
= !trace_redisplay_p
;
18659 arg
= Fprefix_numeric_value (arg
);
18660 trace_redisplay_p
= XINT (arg
) > 0;
18667 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
18668 doc
: /* Like `format', but print result to stderr.
18669 usage: (trace-to-stderr STRING &rest OBJECTS) */)
18670 (ptrdiff_t nargs
, Lisp_Object
*args
)
18672 Lisp_Object s
= Fformat (nargs
, args
);
18673 fprintf (stderr
, "%s", SDATA (s
));
18677 #endif /* GLYPH_DEBUG */
18681 /***********************************************************************
18682 Building Desired Matrix Rows
18683 ***********************************************************************/
18685 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
18686 Used for non-window-redisplay windows, and for windows w/o left fringe. */
18688 static struct glyph_row
*
18689 get_overlay_arrow_glyph_row (struct window
*w
, Lisp_Object overlay_arrow_string
)
18691 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
18692 struct buffer
*buffer
= XBUFFER (w
->contents
);
18693 struct buffer
*old
= current_buffer
;
18694 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
18695 int arrow_len
= SCHARS (overlay_arrow_string
);
18696 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
18697 const unsigned char *p
;
18700 int n_glyphs_before
;
18702 set_buffer_temp (buffer
);
18703 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
18704 it
.glyph_row
->used
[TEXT_AREA
] = 0;
18705 SET_TEXT_POS (it
.position
, 0, 0);
18707 multibyte_p
= !NILP (BVAR (buffer
, enable_multibyte_characters
));
18709 while (p
< arrow_end
)
18711 Lisp_Object face
, ilisp
;
18713 /* Get the next character. */
18715 it
.c
= it
.char_to_display
= string_char_and_length (p
, &it
.len
);
18718 it
.c
= it
.char_to_display
= *p
, it
.len
= 1;
18719 if (! ASCII_CHAR_P (it
.c
))
18720 it
.char_to_display
= BYTE8_TO_CHAR (it
.c
);
18724 /* Get its face. */
18725 ilisp
= make_number (p
- arrow_string
);
18726 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
18727 it
.face_id
= compute_char_face (f
, it
.char_to_display
, face
);
18729 /* Compute its width, get its glyphs. */
18730 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
18731 SET_TEXT_POS (it
.position
, -1, -1);
18732 PRODUCE_GLYPHS (&it
);
18734 /* If this character doesn't fit any more in the line, we have
18735 to remove some glyphs. */
18736 if (it
.current_x
> it
.last_visible_x
)
18738 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
18743 set_buffer_temp (old
);
18744 return it
.glyph_row
;
18748 /* Insert truncation glyphs at the start of IT->glyph_row. Which
18749 glyphs to insert is determined by produce_special_glyphs. */
18752 insert_left_trunc_glyphs (struct it
*it
)
18754 struct it truncate_it
;
18755 struct glyph
*from
, *end
, *to
, *toend
;
18757 eassert (!FRAME_WINDOW_P (it
->f
)
18758 || (!it
->glyph_row
->reversed_p
18759 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0)
18760 || (it
->glyph_row
->reversed_p
18761 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0));
18763 /* Get the truncation glyphs. */
18765 truncate_it
.current_x
= 0;
18766 truncate_it
.face_id
= DEFAULT_FACE_ID
;
18767 truncate_it
.glyph_row
= &scratch_glyph_row
;
18768 truncate_it
.area
= TEXT_AREA
;
18769 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
18770 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
18771 truncate_it
.object
= make_number (0);
18772 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
18774 /* Overwrite glyphs from IT with truncation glyphs. */
18775 if (!it
->glyph_row
->reversed_p
)
18777 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18779 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18780 end
= from
+ tused
;
18781 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18782 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
18783 if (FRAME_WINDOW_P (it
->f
))
18785 /* On GUI frames, when variable-size fonts are displayed,
18786 the truncation glyphs may need more pixels than the row's
18787 glyphs they overwrite. We overwrite more glyphs to free
18788 enough screen real estate, and enlarge the stretch glyph
18789 on the right (see display_line), if there is one, to
18790 preserve the screen position of the truncation glyphs on
18793 struct glyph
*g
= to
;
18796 /* The first glyph could be partially visible, in which case
18797 it->glyph_row->x will be negative. But we want the left
18798 truncation glyphs to be aligned at the left margin of the
18799 window, so we override the x coordinate at which the row
18801 it
->glyph_row
->x
= 0;
18802 while (g
< toend
&& w
< it
->truncation_pixel_width
)
18804 w
+= g
->pixel_width
;
18807 if (g
- to
- tused
> 0)
18809 memmove (to
+ tused
, g
, (toend
- g
) * sizeof(*g
));
18810 it
->glyph_row
->used
[TEXT_AREA
] -= g
- to
- tused
;
18812 used
= it
->glyph_row
->used
[TEXT_AREA
];
18813 if (it
->glyph_row
->truncated_on_right_p
18814 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
18815 && it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].type
18818 int extra
= w
- it
->truncation_pixel_width
;
18820 it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].pixel_width
+= extra
;
18827 /* There may be padding glyphs left over. Overwrite them too. */
18828 if (!FRAME_WINDOW_P (it
->f
))
18830 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
18832 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18839 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
18843 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18845 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
18846 that back to front. */
18847 end
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18848 from
= end
+ truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18849 toend
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18850 to
= toend
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18851 if (FRAME_WINDOW_P (it
->f
))
18854 struct glyph
*g
= to
;
18856 while (g
>= toend
&& w
< it
->truncation_pixel_width
)
18858 w
+= g
->pixel_width
;
18861 if (to
- g
- tused
> 0)
18863 if (it
->glyph_row
->truncated_on_right_p
18864 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0
18865 && it
->glyph_row
->glyphs
[TEXT_AREA
][1].type
== STRETCH_GLYPH
)
18867 int extra
= w
- it
->truncation_pixel_width
;
18869 it
->glyph_row
->glyphs
[TEXT_AREA
][1].pixel_width
+= extra
;
18873 while (from
>= end
&& to
>= toend
)
18875 if (!FRAME_WINDOW_P (it
->f
))
18877 while (to
>= toend
&& CHAR_GLYPH_PADDING_P (*to
))
18880 truncate_it
.glyph_row
->glyphs
[TEXT_AREA
]
18881 + truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18882 while (from
>= end
&& to
>= toend
)
18888 /* Need to free some room before prepending additional
18890 int move_by
= from
- end
+ 1;
18891 struct glyph
*g0
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18892 struct glyph
*g
= g0
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18894 for ( ; g
>= g0
; g
--)
18896 while (from
>= end
)
18898 it
->glyph_row
->used
[TEXT_AREA
] += move_by
;
18903 /* Compute the hash code for ROW. */
18905 row_hash (struct glyph_row
*row
)
18908 unsigned hashval
= 0;
18910 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18911 for (k
= 0; k
< row
->used
[area
]; ++k
)
18912 hashval
= ((((hashval
<< 4) + (hashval
>> 24)) & 0x0fffffff)
18913 + row
->glyphs
[area
][k
].u
.val
18914 + row
->glyphs
[area
][k
].face_id
18915 + row
->glyphs
[area
][k
].padding_p
18916 + (row
->glyphs
[area
][k
].type
<< 2));
18921 /* Compute the pixel height and width of IT->glyph_row.
18923 Most of the time, ascent and height of a display line will be equal
18924 to the max_ascent and max_height values of the display iterator
18925 structure. This is not the case if
18927 1. We hit ZV without displaying anything. In this case, max_ascent
18928 and max_height will be zero.
18930 2. We have some glyphs that don't contribute to the line height.
18931 (The glyph row flag contributes_to_line_height_p is for future
18932 pixmap extensions).
18934 The first case is easily covered by using default values because in
18935 these cases, the line height does not really matter, except that it
18936 must not be zero. */
18939 compute_line_metrics (struct it
*it
)
18941 struct glyph_row
*row
= it
->glyph_row
;
18943 if (FRAME_WINDOW_P (it
->f
))
18945 int i
, min_y
, max_y
;
18947 /* The line may consist of one space only, that was added to
18948 place the cursor on it. If so, the row's height hasn't been
18950 if (row
->height
== 0)
18952 if (it
->max_ascent
+ it
->max_descent
== 0)
18953 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
18954 row
->ascent
= it
->max_ascent
;
18955 row
->height
= it
->max_ascent
+ it
->max_descent
;
18956 row
->phys_ascent
= it
->max_phys_ascent
;
18957 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
18958 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
18961 /* Compute the width of this line. */
18962 row
->pixel_width
= row
->x
;
18963 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
18964 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
18966 eassert (row
->pixel_width
>= 0);
18967 eassert (row
->ascent
>= 0 && row
->height
> 0);
18969 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
18970 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
18972 /* If first line's physical ascent is larger than its logical
18973 ascent, use the physical ascent, and make the row taller.
18974 This makes accented characters fully visible. */
18975 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
18976 && row
->phys_ascent
> row
->ascent
)
18978 row
->height
+= row
->phys_ascent
- row
->ascent
;
18979 row
->ascent
= row
->phys_ascent
;
18982 /* Compute how much of the line is visible. */
18983 row
->visible_height
= row
->height
;
18985 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
18986 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
18988 if (row
->y
< min_y
)
18989 row
->visible_height
-= min_y
- row
->y
;
18990 if (row
->y
+ row
->height
> max_y
)
18991 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
18995 row
->pixel_width
= row
->used
[TEXT_AREA
];
18996 if (row
->continued_p
)
18997 row
->pixel_width
-= it
->continuation_pixel_width
;
18998 else if (row
->truncated_on_right_p
)
18999 row
->pixel_width
-= it
->truncation_pixel_width
;
19000 row
->ascent
= row
->phys_ascent
= 0;
19001 row
->height
= row
->phys_height
= row
->visible_height
= 1;
19002 row
->extra_line_spacing
= 0;
19005 /* Compute a hash code for this row. */
19006 row
->hash
= row_hash (row
);
19008 it
->max_ascent
= it
->max_descent
= 0;
19009 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
19013 /* Append one space to the glyph row of iterator IT if doing a
19014 window-based redisplay. The space has the same face as
19015 IT->face_id. Value is non-zero if a space was added.
19017 This function is called to make sure that there is always one glyph
19018 at the end of a glyph row that the cursor can be set on under
19019 window-systems. (If there weren't such a glyph we would not know
19020 how wide and tall a box cursor should be displayed).
19022 At the same time this space let's a nicely handle clearing to the
19023 end of the line if the row ends in italic text. */
19026 append_space_for_newline (struct it
*it
, int default_face_p
)
19028 if (FRAME_WINDOW_P (it
->f
))
19030 int n
= it
->glyph_row
->used
[TEXT_AREA
];
19032 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
19033 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
19035 /* Save some values that must not be changed.
19036 Must save IT->c and IT->len because otherwise
19037 ITERATOR_AT_END_P wouldn't work anymore after
19038 append_space_for_newline has been called. */
19039 enum display_element_type saved_what
= it
->what
;
19040 int saved_c
= it
->c
, saved_len
= it
->len
;
19041 int saved_char_to_display
= it
->char_to_display
;
19042 int saved_x
= it
->current_x
;
19043 int saved_face_id
= it
->face_id
;
19044 int saved_box_end
= it
->end_of_box_run_p
;
19045 struct text_pos saved_pos
;
19046 Lisp_Object saved_object
;
19049 saved_object
= it
->object
;
19050 saved_pos
= it
->position
;
19052 it
->what
= IT_CHARACTER
;
19053 memset (&it
->position
, 0, sizeof it
->position
);
19054 it
->object
= make_number (0);
19055 it
->c
= it
->char_to_display
= ' ';
19058 /* If the default face was remapped, be sure to use the
19059 remapped face for the appended newline. */
19060 if (default_face_p
)
19061 it
->face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);
19062 else if (it
->face_before_selective_p
)
19063 it
->face_id
= it
->saved_face_id
;
19064 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
19065 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
19066 /* In R2L rows, we will prepend a stretch glyph that will
19067 have the end_of_box_run_p flag set for it, so there's no
19068 need for the appended newline glyph to have that flag
19070 if (it
->glyph_row
->reversed_p
19071 /* But if the appended newline glyph goes all the way to
19072 the end of the row, there will be no stretch glyph,
19073 so leave the box flag set. */
19074 && saved_x
+ FRAME_COLUMN_WIDTH (it
->f
) < it
->last_visible_x
)
19075 it
->end_of_box_run_p
= 0;
19077 PRODUCE_GLYPHS (it
);
19079 it
->override_ascent
= -1;
19080 it
->constrain_row_ascent_descent_p
= 0;
19081 it
->current_x
= saved_x
;
19082 it
->object
= saved_object
;
19083 it
->position
= saved_pos
;
19084 it
->what
= saved_what
;
19085 it
->face_id
= saved_face_id
;
19086 it
->len
= saved_len
;
19088 it
->char_to_display
= saved_char_to_display
;
19089 it
->end_of_box_run_p
= saved_box_end
;
19098 /* Extend the face of the last glyph in the text area of IT->glyph_row
19099 to the end of the display line. Called from display_line. If the
19100 glyph row is empty, add a space glyph to it so that we know the
19101 face to draw. Set the glyph row flag fill_line_p. If the glyph
19102 row is R2L, prepend a stretch glyph to cover the empty space to the
19103 left of the leftmost glyph. */
19106 extend_face_to_end_of_line (struct it
*it
)
19108 struct face
*face
, *default_face
;
19109 struct frame
*f
= it
->f
;
19111 /* If line is already filled, do nothing. Non window-system frames
19112 get a grace of one more ``pixel'' because their characters are
19113 1-``pixel'' wide, so they hit the equality too early. This grace
19114 is needed only for R2L rows that are not continued, to produce
19115 one extra blank where we could display the cursor. */
19116 if ((it
->current_x
>= it
->last_visible_x
19117 + (!FRAME_WINDOW_P (f
)
19118 && it
->glyph_row
->reversed_p
19119 && !it
->glyph_row
->continued_p
))
19120 /* If the window has display margins, we will need to extend
19121 their face even if the text area is filled. */
19122 && !(WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
19123 || WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0))
19126 /* The default face, possibly remapped. */
19127 default_face
= FACE_FROM_ID (f
, lookup_basic_face (f
, DEFAULT_FACE_ID
));
19129 /* Face extension extends the background and box of IT->face_id
19130 to the end of the line. If the background equals the background
19131 of the frame, we don't have to do anything. */
19132 if (it
->face_before_selective_p
)
19133 face
= FACE_FROM_ID (f
, it
->saved_face_id
);
19135 face
= FACE_FROM_ID (f
, it
->face_id
);
19137 if (FRAME_WINDOW_P (f
)
19138 && MATRIX_ROW_DISPLAYS_TEXT_P (it
->glyph_row
)
19139 && face
->box
== FACE_NO_BOX
19140 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
19141 #ifdef HAVE_WINDOW_SYSTEM
19144 && !it
->glyph_row
->reversed_p
)
19147 /* Set the glyph row flag indicating that the face of the last glyph
19148 in the text area has to be drawn to the end of the text area. */
19149 it
->glyph_row
->fill_line_p
= 1;
19151 /* If current character of IT is not ASCII, make sure we have the
19152 ASCII face. This will be automatically undone the next time
19153 get_next_display_element returns a multibyte character. Note
19154 that the character will always be single byte in unibyte
19156 if (!ASCII_CHAR_P (it
->c
))
19158 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
19161 if (FRAME_WINDOW_P (f
))
19163 /* If the row is empty, add a space with the current face of IT,
19164 so that we know which face to draw. */
19165 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
19167 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
19168 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= face
->id
;
19169 it
->glyph_row
->used
[TEXT_AREA
] = 1;
19171 /* Mode line and the header line don't have margins, and
19172 likewise the frame's tool-bar window, if there is any. */
19173 if (!(it
->glyph_row
->mode_line_p
19174 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
19175 || (WINDOWP (f
->tool_bar_window
)
19176 && it
->w
== XWINDOW (f
->tool_bar_window
))
19180 if (WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
19181 && it
->glyph_row
->used
[LEFT_MARGIN_AREA
] == 0)
19183 it
->glyph_row
->glyphs
[LEFT_MARGIN_AREA
][0] = space_glyph
;
19184 it
->glyph_row
->glyphs
[LEFT_MARGIN_AREA
][0].face_id
=
19186 it
->glyph_row
->used
[LEFT_MARGIN_AREA
] = 1;
19188 if (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0
19189 && it
->glyph_row
->used
[RIGHT_MARGIN_AREA
] == 0)
19191 it
->glyph_row
->glyphs
[RIGHT_MARGIN_AREA
][0] = space_glyph
;
19192 it
->glyph_row
->glyphs
[RIGHT_MARGIN_AREA
][0].face_id
=
19194 it
->glyph_row
->used
[RIGHT_MARGIN_AREA
] = 1;
19197 #ifdef HAVE_WINDOW_SYSTEM
19198 if (it
->glyph_row
->reversed_p
)
19200 /* Prepend a stretch glyph to the row, such that the
19201 rightmost glyph will be drawn flushed all the way to the
19202 right margin of the window. The stretch glyph that will
19203 occupy the empty space, if any, to the left of the
19205 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (f
);
19206 struct glyph
*row_start
= it
->glyph_row
->glyphs
[TEXT_AREA
];
19207 struct glyph
*row_end
= row_start
+ it
->glyph_row
->used
[TEXT_AREA
];
19209 int row_width
, stretch_ascent
, stretch_width
;
19210 struct text_pos saved_pos
;
19211 int saved_face_id
, saved_avoid_cursor
, saved_box_start
;
19213 for (row_width
= 0, g
= row_start
; g
< row_end
; g
++)
19214 row_width
+= g
->pixel_width
;
19215 stretch_width
= window_box_width (it
->w
, TEXT_AREA
) - row_width
;
19216 if (stretch_width
> 0)
19219 (((it
->ascent
+ it
->descent
)
19220 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
19221 saved_pos
= it
->position
;
19222 memset (&it
->position
, 0, sizeof it
->position
);
19223 saved_avoid_cursor
= it
->avoid_cursor_p
;
19224 it
->avoid_cursor_p
= 1;
19225 saved_face_id
= it
->face_id
;
19226 saved_box_start
= it
->start_of_box_run_p
;
19227 /* The last row's stretch glyph should get the default
19228 face, to avoid painting the rest of the window with
19229 the region face, if the region ends at ZV. */
19230 if (it
->glyph_row
->ends_at_zv_p
)
19231 it
->face_id
= default_face
->id
;
19233 it
->face_id
= face
->id
;
19234 it
->start_of_box_run_p
= 0;
19235 append_stretch_glyph (it
, make_number (0), stretch_width
,
19236 it
->ascent
+ it
->descent
, stretch_ascent
);
19237 it
->position
= saved_pos
;
19238 it
->avoid_cursor_p
= saved_avoid_cursor
;
19239 it
->face_id
= saved_face_id
;
19240 it
->start_of_box_run_p
= saved_box_start
;
19243 #endif /* HAVE_WINDOW_SYSTEM */
19247 /* Save some values that must not be changed. */
19248 int saved_x
= it
->current_x
;
19249 struct text_pos saved_pos
;
19250 Lisp_Object saved_object
;
19251 enum display_element_type saved_what
= it
->what
;
19252 int saved_face_id
= it
->face_id
;
19254 saved_object
= it
->object
;
19255 saved_pos
= it
->position
;
19257 it
->what
= IT_CHARACTER
;
19258 memset (&it
->position
, 0, sizeof it
->position
);
19259 it
->object
= make_number (0);
19260 it
->c
= it
->char_to_display
= ' ';
19263 if (WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
19264 && (it
->glyph_row
->used
[LEFT_MARGIN_AREA
]
19265 < WINDOW_LEFT_MARGIN_WIDTH (it
->w
))
19266 && !it
->glyph_row
->mode_line_p
19267 && default_face
->background
!= FRAME_BACKGROUND_PIXEL (f
))
19269 struct glyph
*g
= it
->glyph_row
->glyphs
[LEFT_MARGIN_AREA
];
19270 struct glyph
*e
= g
+ it
->glyph_row
->used
[LEFT_MARGIN_AREA
];
19272 for (it
->current_x
= 0; g
< e
; g
++)
19273 it
->current_x
+= g
->pixel_width
;
19275 it
->area
= LEFT_MARGIN_AREA
;
19276 it
->face_id
= default_face
->id
;
19277 while (it
->glyph_row
->used
[LEFT_MARGIN_AREA
]
19278 < WINDOW_LEFT_MARGIN_WIDTH (it
->w
))
19280 PRODUCE_GLYPHS (it
);
19281 /* term.c:produce_glyphs advances it->current_x only for
19283 it
->current_x
+= it
->pixel_width
;
19286 it
->current_x
= saved_x
;
19287 it
->area
= TEXT_AREA
;
19290 /* The last row's blank glyphs should get the default face, to
19291 avoid painting the rest of the window with the region face,
19292 if the region ends at ZV. */
19293 if (it
->glyph_row
->ends_at_zv_p
)
19294 it
->face_id
= default_face
->id
;
19296 it
->face_id
= face
->id
;
19297 PRODUCE_GLYPHS (it
);
19299 while (it
->current_x
<= it
->last_visible_x
)
19300 PRODUCE_GLYPHS (it
);
19302 if (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0
19303 && (it
->glyph_row
->used
[RIGHT_MARGIN_AREA
]
19304 < WINDOW_RIGHT_MARGIN_WIDTH (it
->w
))
19305 && !it
->glyph_row
->mode_line_p
19306 && default_face
->background
!= FRAME_BACKGROUND_PIXEL (f
))
19308 struct glyph
*g
= it
->glyph_row
->glyphs
[RIGHT_MARGIN_AREA
];
19309 struct glyph
*e
= g
+ it
->glyph_row
->used
[RIGHT_MARGIN_AREA
];
19311 for ( ; g
< e
; g
++)
19312 it
->current_x
+= g
->pixel_width
;
19314 it
->area
= RIGHT_MARGIN_AREA
;
19315 it
->face_id
= default_face
->id
;
19316 while (it
->glyph_row
->used
[RIGHT_MARGIN_AREA
]
19317 < WINDOW_RIGHT_MARGIN_WIDTH (it
->w
))
19319 PRODUCE_GLYPHS (it
);
19320 it
->current_x
+= it
->pixel_width
;
19323 it
->area
= TEXT_AREA
;
19326 /* Don't count these blanks really. It would let us insert a left
19327 truncation glyph below and make us set the cursor on them, maybe. */
19328 it
->current_x
= saved_x
;
19329 it
->object
= saved_object
;
19330 it
->position
= saved_pos
;
19331 it
->what
= saved_what
;
19332 it
->face_id
= saved_face_id
;
19337 /* Value is non-zero if text starting at CHARPOS in current_buffer is
19338 trailing whitespace. */
19341 trailing_whitespace_p (ptrdiff_t charpos
)
19343 ptrdiff_t bytepos
= CHAR_TO_BYTE (charpos
);
19346 while (bytepos
< ZV_BYTE
19347 && (c
= FETCH_CHAR (bytepos
),
19348 c
== ' ' || c
== '\t'))
19351 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
19353 if (bytepos
!= PT_BYTE
)
19360 /* Highlight trailing whitespace, if any, in ROW. */
19363 highlight_trailing_whitespace (struct frame
*f
, struct glyph_row
*row
)
19365 int used
= row
->used
[TEXT_AREA
];
19369 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
19370 struct glyph
*glyph
= start
+ used
- 1;
19372 if (row
->reversed_p
)
19374 /* Right-to-left rows need to be processed in the opposite
19375 direction, so swap the edge pointers. */
19377 start
= row
->glyphs
[TEXT_AREA
] + used
- 1;
19380 /* Skip over glyphs inserted to display the cursor at the
19381 end of a line, for extending the face of the last glyph
19382 to the end of the line on terminals, and for truncation
19383 and continuation glyphs. */
19384 if (!row
->reversed_p
)
19386 while (glyph
>= start
19387 && glyph
->type
== CHAR_GLYPH
19388 && INTEGERP (glyph
->object
))
19393 while (glyph
<= start
19394 && glyph
->type
== CHAR_GLYPH
19395 && INTEGERP (glyph
->object
))
19399 /* If last glyph is a space or stretch, and it's trailing
19400 whitespace, set the face of all trailing whitespace glyphs in
19401 IT->glyph_row to `trailing-whitespace'. */
19402 if ((row
->reversed_p
? glyph
<= start
: glyph
>= start
)
19403 && BUFFERP (glyph
->object
)
19404 && (glyph
->type
== STRETCH_GLYPH
19405 || (glyph
->type
== CHAR_GLYPH
19406 && glyph
->u
.ch
== ' '))
19407 && trailing_whitespace_p (glyph
->charpos
))
19409 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
19413 if (!row
->reversed_p
)
19415 while (glyph
>= start
19416 && BUFFERP (glyph
->object
)
19417 && (glyph
->type
== STRETCH_GLYPH
19418 || (glyph
->type
== CHAR_GLYPH
19419 && glyph
->u
.ch
== ' ')))
19420 (glyph
--)->face_id
= face_id
;
19424 while (glyph
<= start
19425 && BUFFERP (glyph
->object
)
19426 && (glyph
->type
== STRETCH_GLYPH
19427 || (glyph
->type
== CHAR_GLYPH
19428 && glyph
->u
.ch
== ' ')))
19429 (glyph
++)->face_id
= face_id
;
19436 /* Value is non-zero if glyph row ROW should be
19437 considered to hold the buffer position CHARPOS. */
19440 row_for_charpos_p (struct glyph_row
*row
, ptrdiff_t charpos
)
19444 if (charpos
== CHARPOS (row
->end
.pos
)
19445 || charpos
== MATRIX_ROW_END_CHARPOS (row
))
19447 /* Suppose the row ends on a string.
19448 Unless the row is continued, that means it ends on a newline
19449 in the string. If it's anything other than a display string
19450 (e.g., a before-string from an overlay), we don't want the
19451 cursor there. (This heuristic seems to give the optimal
19452 behavior for the various types of multi-line strings.)
19453 One exception: if the string has `cursor' property on one of
19454 its characters, we _do_ want the cursor there. */
19455 if (CHARPOS (row
->end
.string_pos
) >= 0)
19457 if (row
->continued_p
)
19461 /* Check for `display' property. */
19462 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
19463 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
19464 struct glyph
*glyph
;
19467 for (glyph
= end
; glyph
>= beg
; --glyph
)
19468 if (STRINGP (glyph
->object
))
19471 = Fget_char_property (make_number (charpos
),
19475 && display_prop_string_p (prop
, glyph
->object
));
19476 /* If there's a `cursor' property on one of the
19477 string's characters, this row is a cursor row,
19478 even though this is not a display string. */
19481 Lisp_Object s
= glyph
->object
;
19483 for ( ; glyph
>= beg
&& EQ (glyph
->object
, s
); --glyph
)
19485 ptrdiff_t gpos
= glyph
->charpos
;
19487 if (!NILP (Fget_char_property (make_number (gpos
),
19499 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
19501 /* If the row ends in middle of a real character,
19502 and the line is continued, we want the cursor here.
19503 That's because CHARPOS (ROW->end.pos) would equal
19504 PT if PT is before the character. */
19505 if (!row
->ends_in_ellipsis_p
)
19506 result
= row
->continued_p
;
19508 /* If the row ends in an ellipsis, then
19509 CHARPOS (ROW->end.pos) will equal point after the
19510 invisible text. We want that position to be displayed
19511 after the ellipsis. */
19514 /* If the row ends at ZV, display the cursor at the end of that
19515 row instead of at the start of the row below. */
19516 else if (row
->ends_at_zv_p
)
19525 /* Value is non-zero if glyph row ROW should be
19526 used to hold the cursor. */
19529 cursor_row_p (struct glyph_row
*row
)
19531 return row_for_charpos_p (row
, PT
);
19536 /* Push the property PROP so that it will be rendered at the current
19537 position in IT. Return 1 if PROP was successfully pushed, 0
19538 otherwise. Called from handle_line_prefix to handle the
19539 `line-prefix' and `wrap-prefix' properties. */
19542 push_prefix_prop (struct it
*it
, Lisp_Object prop
)
19544 struct text_pos pos
=
19545 STRINGP (it
->string
) ? it
->current
.string_pos
: it
->current
.pos
;
19547 eassert (it
->method
== GET_FROM_BUFFER
19548 || it
->method
== GET_FROM_DISPLAY_VECTOR
19549 || it
->method
== GET_FROM_STRING
);
19551 /* We need to save the current buffer/string position, so it will be
19552 restored by pop_it, because iterate_out_of_display_property
19553 depends on that being set correctly, but some situations leave
19554 it->position not yet set when this function is called. */
19555 push_it (it
, &pos
);
19557 if (STRINGP (prop
))
19559 if (SCHARS (prop
) == 0)
19566 it
->string_from_prefix_prop_p
= 1;
19567 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
19568 it
->current
.overlay_string_index
= -1;
19569 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
19570 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
19571 it
->method
= GET_FROM_STRING
;
19572 it
->stop_charpos
= 0;
19574 it
->base_level_stop
= 0;
19576 /* Force paragraph direction to be that of the parent
19578 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
19579 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
19581 it
->paragraph_embedding
= L2R
;
19583 /* Set up the bidi iterator for this display string. */
19586 it
->bidi_it
.string
.lstring
= it
->string
;
19587 it
->bidi_it
.string
.s
= NULL
;
19588 it
->bidi_it
.string
.schars
= it
->end_charpos
;
19589 it
->bidi_it
.string
.bufpos
= IT_CHARPOS (*it
);
19590 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
19591 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
19592 it
->bidi_it
.w
= it
->w
;
19593 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
19596 else if (CONSP (prop
) && EQ (XCAR (prop
), Qspace
))
19598 it
->method
= GET_FROM_STRETCH
;
19601 #ifdef HAVE_WINDOW_SYSTEM
19602 else if (IMAGEP (prop
))
19604 it
->what
= IT_IMAGE
;
19605 it
->image_id
= lookup_image (it
->f
, prop
);
19606 it
->method
= GET_FROM_IMAGE
;
19608 #endif /* HAVE_WINDOW_SYSTEM */
19611 pop_it (it
); /* bogus display property, give up */
19618 /* Return the character-property PROP at the current position in IT. */
19621 get_it_property (struct it
*it
, Lisp_Object prop
)
19623 Lisp_Object position
, object
= it
->object
;
19625 if (STRINGP (object
))
19626 position
= make_number (IT_STRING_CHARPOS (*it
));
19627 else if (BUFFERP (object
))
19629 position
= make_number (IT_CHARPOS (*it
));
19630 object
= it
->window
;
19635 return Fget_char_property (position
, prop
, object
);
19638 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
19641 handle_line_prefix (struct it
*it
)
19643 Lisp_Object prefix
;
19645 if (it
->continuation_lines_width
> 0)
19647 prefix
= get_it_property (it
, Qwrap_prefix
);
19649 prefix
= Vwrap_prefix
;
19653 prefix
= get_it_property (it
, Qline_prefix
);
19655 prefix
= Vline_prefix
;
19657 if (! NILP (prefix
) && push_prefix_prop (it
, prefix
))
19659 /* If the prefix is wider than the window, and we try to wrap
19660 it, it would acquire its own wrap prefix, and so on till the
19661 iterator stack overflows. So, don't wrap the prefix. */
19662 it
->line_wrap
= TRUNCATE
;
19663 it
->avoid_cursor_p
= 1;
19669 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
19670 only for R2L lines from display_line and display_string, when they
19671 decide that too many glyphs were produced by PRODUCE_GLYPHS, and
19672 the line/string needs to be continued on the next glyph row. */
19674 unproduce_glyphs (struct it
*it
, int n
)
19676 struct glyph
*glyph
, *end
;
19678 eassert (it
->glyph_row
);
19679 eassert (it
->glyph_row
->reversed_p
);
19680 eassert (it
->area
== TEXT_AREA
);
19681 eassert (n
<= it
->glyph_row
->used
[TEXT_AREA
]);
19683 if (n
> it
->glyph_row
->used
[TEXT_AREA
])
19684 n
= it
->glyph_row
->used
[TEXT_AREA
];
19685 glyph
= it
->glyph_row
->glyphs
[TEXT_AREA
] + n
;
19686 end
= it
->glyph_row
->glyphs
[TEXT_AREA
] + it
->glyph_row
->used
[TEXT_AREA
];
19687 for ( ; glyph
< end
; glyph
++)
19688 glyph
[-n
] = *glyph
;
19691 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
19692 and ROW->maxpos. */
19694 find_row_edges (struct it
*it
, struct glyph_row
*row
,
19695 ptrdiff_t min_pos
, ptrdiff_t min_bpos
,
19696 ptrdiff_t max_pos
, ptrdiff_t max_bpos
)
19698 /* FIXME: Revisit this when glyph ``spilling'' in continuation
19699 lines' rows is implemented for bidi-reordered rows. */
19701 /* ROW->minpos is the value of min_pos, the minimal buffer position
19702 we have in ROW, or ROW->start.pos if that is smaller. */
19703 if (min_pos
<= ZV
&& min_pos
< row
->start
.pos
.charpos
)
19704 SET_TEXT_POS (row
->minpos
, min_pos
, min_bpos
);
19706 /* We didn't find buffer positions smaller than ROW->start, or
19707 didn't find _any_ valid buffer positions in any of the glyphs,
19708 so we must trust the iterator's computed positions. */
19709 row
->minpos
= row
->start
.pos
;
19712 max_pos
= CHARPOS (it
->current
.pos
);
19713 max_bpos
= BYTEPOS (it
->current
.pos
);
19716 /* Here are the various use-cases for ending the row, and the
19717 corresponding values for ROW->maxpos:
19719 Line ends in a newline from buffer eol_pos + 1
19720 Line is continued from buffer max_pos + 1
19721 Line is truncated on right it->current.pos
19722 Line ends in a newline from string max_pos + 1(*)
19723 (*) + 1 only when line ends in a forward scan
19724 Line is continued from string max_pos
19725 Line is continued from display vector max_pos
19726 Line is entirely from a string min_pos == max_pos
19727 Line is entirely from a display vector min_pos == max_pos
19728 Line that ends at ZV ZV
19730 If you discover other use-cases, please add them here as
19732 if (row
->ends_at_zv_p
)
19733 row
->maxpos
= it
->current
.pos
;
19734 else if (row
->used
[TEXT_AREA
])
19736 int seen_this_string
= 0;
19737 struct glyph_row
*r1
= row
- 1;
19739 /* Did we see the same display string on the previous row? */
19740 if (STRINGP (it
->object
)
19741 /* this is not the first row */
19742 && row
> it
->w
->desired_matrix
->rows
19743 /* previous row is not the header line */
19744 && !r1
->mode_line_p
19745 /* previous row also ends in a newline from a string */
19746 && r1
->ends_in_newline_from_string_p
)
19748 struct glyph
*start
, *end
;
19750 /* Search for the last glyph of the previous row that came
19751 from buffer or string. Depending on whether the row is
19752 L2R or R2L, we need to process it front to back or the
19753 other way round. */
19754 if (!r1
->reversed_p
)
19756 start
= r1
->glyphs
[TEXT_AREA
];
19757 end
= start
+ r1
->used
[TEXT_AREA
];
19758 /* Glyphs inserted by redisplay have an integer (zero)
19759 as their object. */
19761 && INTEGERP ((end
- 1)->object
)
19762 && (end
- 1)->charpos
<= 0)
19766 if (EQ ((end
- 1)->object
, it
->object
))
19767 seen_this_string
= 1;
19770 /* If all the glyphs of the previous row were inserted
19771 by redisplay, it means the previous row was
19772 produced from a single newline, which is only
19773 possible if that newline came from the same string
19774 as the one which produced this ROW. */
19775 seen_this_string
= 1;
19779 end
= r1
->glyphs
[TEXT_AREA
] - 1;
19780 start
= end
+ r1
->used
[TEXT_AREA
];
19782 && INTEGERP ((end
+ 1)->object
)
19783 && (end
+ 1)->charpos
<= 0)
19787 if (EQ ((end
+ 1)->object
, it
->object
))
19788 seen_this_string
= 1;
19791 seen_this_string
= 1;
19794 /* Take note of each display string that covers a newline only
19795 once, the first time we see it. This is for when a display
19796 string includes more than one newline in it. */
19797 if (row
->ends_in_newline_from_string_p
&& !seen_this_string
)
19799 /* If we were scanning the buffer forward when we displayed
19800 the string, we want to account for at least one buffer
19801 position that belongs to this row (position covered by
19802 the display string), so that cursor positioning will
19803 consider this row as a candidate when point is at the end
19804 of the visual line represented by this row. This is not
19805 required when scanning back, because max_pos will already
19806 have a much larger value. */
19807 if (CHARPOS (row
->end
.pos
) > max_pos
)
19808 INC_BOTH (max_pos
, max_bpos
);
19809 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19811 else if (CHARPOS (it
->eol_pos
) > 0)
19812 SET_TEXT_POS (row
->maxpos
,
19813 CHARPOS (it
->eol_pos
) + 1, BYTEPOS (it
->eol_pos
) + 1);
19814 else if (row
->continued_p
)
19816 /* If max_pos is different from IT's current position, it
19817 means IT->method does not belong to the display element
19818 at max_pos. However, it also means that the display
19819 element at max_pos was displayed in its entirety on this
19820 line, which is equivalent to saying that the next line
19821 starts at the next buffer position. */
19822 if (IT_CHARPOS (*it
) == max_pos
&& it
->method
!= GET_FROM_BUFFER
)
19823 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19826 INC_BOTH (max_pos
, max_bpos
);
19827 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19830 else if (row
->truncated_on_right_p
)
19831 /* display_line already called reseat_at_next_visible_line_start,
19832 which puts the iterator at the beginning of the next line, in
19833 the logical order. */
19834 row
->maxpos
= it
->current
.pos
;
19835 else if (max_pos
== min_pos
&& it
->method
!= GET_FROM_BUFFER
)
19836 /* A line that is entirely from a string/image/stretch... */
19837 row
->maxpos
= row
->minpos
;
19842 row
->maxpos
= it
->current
.pos
;
19845 /* Construct the glyph row IT->glyph_row in the desired matrix of
19846 IT->w from text at the current position of IT. See dispextern.h
19847 for an overview of struct it. Value is non-zero if
19848 IT->glyph_row displays text, as opposed to a line displaying ZV
19852 display_line (struct it
*it
)
19854 struct glyph_row
*row
= it
->glyph_row
;
19855 Lisp_Object overlay_arrow_string
;
19857 void *wrap_data
= NULL
;
19858 int may_wrap
= 0, wrap_x
IF_LINT (= 0);
19859 int wrap_row_used
= -1;
19860 int wrap_row_ascent
IF_LINT (= 0), wrap_row_height
IF_LINT (= 0);
19861 int wrap_row_phys_ascent
IF_LINT (= 0), wrap_row_phys_height
IF_LINT (= 0);
19862 int wrap_row_extra_line_spacing
IF_LINT (= 0);
19863 ptrdiff_t wrap_row_min_pos
IF_LINT (= 0), wrap_row_min_bpos
IF_LINT (= 0);
19864 ptrdiff_t wrap_row_max_pos
IF_LINT (= 0), wrap_row_max_bpos
IF_LINT (= 0);
19866 ptrdiff_t min_pos
= ZV
+ 1, max_pos
= 0;
19867 ptrdiff_t min_bpos
IF_LINT (= 0), max_bpos
IF_LINT (= 0);
19869 /* We always start displaying at hpos zero even if hscrolled. */
19870 eassert (it
->hpos
== 0 && it
->current_x
== 0);
19872 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
19873 >= it
->w
->desired_matrix
->nrows
)
19875 it
->w
->nrows_scale_factor
++;
19876 it
->f
->fonts_changed
= 1;
19880 /* Clear the result glyph row and enable it. */
19881 prepare_desired_row (row
);
19883 row
->y
= it
->current_y
;
19884 row
->start
= it
->start
;
19885 row
->continuation_lines_width
= it
->continuation_lines_width
;
19886 row
->displays_text_p
= 1;
19887 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
19888 it
->starts_in_middle_of_char_p
= 0;
19890 /* Arrange the overlays nicely for our purposes. Usually, we call
19891 display_line on only one line at a time, in which case this
19892 can't really hurt too much, or we call it on lines which appear
19893 one after another in the buffer, in which case all calls to
19894 recenter_overlay_lists but the first will be pretty cheap. */
19895 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
19897 /* Move over display elements that are not visible because we are
19898 hscrolled. This may stop at an x-position < IT->first_visible_x
19899 if the first glyph is partially visible or if we hit a line end. */
19900 if (it
->current_x
< it
->first_visible_x
)
19902 enum move_it_result move_result
;
19904 this_line_min_pos
= row
->start
.pos
;
19905 move_result
= move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
19906 MOVE_TO_POS
| MOVE_TO_X
);
19907 /* If we are under a large hscroll, move_it_in_display_line_to
19908 could hit the end of the line without reaching
19909 it->first_visible_x. Pretend that we did reach it. This is
19910 especially important on a TTY, where we will call
19911 extend_face_to_end_of_line, which needs to know how many
19912 blank glyphs to produce. */
19913 if (it
->current_x
< it
->first_visible_x
19914 && (move_result
== MOVE_NEWLINE_OR_CR
19915 || move_result
== MOVE_POS_MATCH_OR_ZV
))
19916 it
->current_x
= it
->first_visible_x
;
19918 /* Record the smallest positions seen while we moved over
19919 display elements that are not visible. This is needed by
19920 redisplay_internal for optimizing the case where the cursor
19921 stays inside the same line. The rest of this function only
19922 considers positions that are actually displayed, so
19923 RECORD_MAX_MIN_POS will not otherwise record positions that
19924 are hscrolled to the left of the left edge of the window. */
19925 min_pos
= CHARPOS (this_line_min_pos
);
19926 min_bpos
= BYTEPOS (this_line_min_pos
);
19930 /* We only do this when not calling `move_it_in_display_line_to'
19931 above, because move_it_in_display_line_to calls
19932 handle_line_prefix itself. */
19933 handle_line_prefix (it
);
19936 /* Get the initial row height. This is either the height of the
19937 text hscrolled, if there is any, or zero. */
19938 row
->ascent
= it
->max_ascent
;
19939 row
->height
= it
->max_ascent
+ it
->max_descent
;
19940 row
->phys_ascent
= it
->max_phys_ascent
;
19941 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
19942 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
19944 /* Utility macro to record max and min buffer positions seen until now. */
19945 #define RECORD_MAX_MIN_POS(IT) \
19948 int composition_p = !STRINGP ((IT)->string) \
19949 && ((IT)->what == IT_COMPOSITION); \
19950 ptrdiff_t current_pos = \
19951 composition_p ? (IT)->cmp_it.charpos \
19952 : IT_CHARPOS (*(IT)); \
19953 ptrdiff_t current_bpos = \
19954 composition_p ? CHAR_TO_BYTE (current_pos) \
19955 : IT_BYTEPOS (*(IT)); \
19956 if (current_pos < min_pos) \
19958 min_pos = current_pos; \
19959 min_bpos = current_bpos; \
19961 if (IT_CHARPOS (*it) > max_pos) \
19963 max_pos = IT_CHARPOS (*it); \
19964 max_bpos = IT_BYTEPOS (*it); \
19969 /* Loop generating characters. The loop is left with IT on the next
19970 character to display. */
19973 int n_glyphs_before
, hpos_before
, x_before
;
19975 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
19977 /* Retrieve the next thing to display. Value is zero if end of
19979 if (!get_next_display_element (it
))
19981 /* Maybe add a space at the end of this line that is used to
19982 display the cursor there under X. Set the charpos of the
19983 first glyph of blank lines not corresponding to any text
19985 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19986 row
->exact_window_width_line_p
= 1;
19987 else if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
19988 || row
->used
[TEXT_AREA
] == 0)
19990 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
19991 row
->displays_text_p
= 0;
19993 if (!NILP (BVAR (XBUFFER (it
->w
->contents
), indicate_empty_lines
))
19994 && (!MINI_WINDOW_P (it
->w
)
19995 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
19996 row
->indicate_empty_line_p
= 1;
19999 it
->continuation_lines_width
= 0;
20000 row
->ends_at_zv_p
= 1;
20001 /* A row that displays right-to-left text must always have
20002 its last face extended all the way to the end of line,
20003 even if this row ends in ZV, because we still write to
20004 the screen left to right. We also need to extend the
20005 last face if the default face is remapped to some
20006 different face, otherwise the functions that clear
20007 portions of the screen will clear with the default face's
20008 background color. */
20009 if (row
->reversed_p
20010 || lookup_basic_face (it
->f
, DEFAULT_FACE_ID
) != DEFAULT_FACE_ID
)
20011 extend_face_to_end_of_line (it
);
20015 /* Now, get the metrics of what we want to display. This also
20016 generates glyphs in `row' (which is IT->glyph_row). */
20017 n_glyphs_before
= row
->used
[TEXT_AREA
];
20020 /* Remember the line height so far in case the next element doesn't
20021 fit on the line. */
20022 if (it
->line_wrap
!= TRUNCATE
)
20024 ascent
= it
->max_ascent
;
20025 descent
= it
->max_descent
;
20026 phys_ascent
= it
->max_phys_ascent
;
20027 phys_descent
= it
->max_phys_descent
;
20029 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
20031 if (IT_DISPLAYING_WHITESPACE (it
))
20035 SAVE_IT (wrap_it
, *it
, wrap_data
);
20037 wrap_row_used
= row
->used
[TEXT_AREA
];
20038 wrap_row_ascent
= row
->ascent
;
20039 wrap_row_height
= row
->height
;
20040 wrap_row_phys_ascent
= row
->phys_ascent
;
20041 wrap_row_phys_height
= row
->phys_height
;
20042 wrap_row_extra_line_spacing
= row
->extra_line_spacing
;
20043 wrap_row_min_pos
= min_pos
;
20044 wrap_row_min_bpos
= min_bpos
;
20045 wrap_row_max_pos
= max_pos
;
20046 wrap_row_max_bpos
= max_bpos
;
20052 PRODUCE_GLYPHS (it
);
20054 /* If this display element was in marginal areas, continue with
20056 if (it
->area
!= TEXT_AREA
)
20058 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
20059 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
20060 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
20061 row
->phys_height
= max (row
->phys_height
,
20062 it
->max_phys_ascent
+ it
->max_phys_descent
);
20063 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
20064 it
->max_extra_line_spacing
);
20065 set_iterator_to_next (it
, 1);
20069 /* Does the display element fit on the line? If we truncate
20070 lines, we should draw past the right edge of the window. If
20071 we don't truncate, we want to stop so that we can display the
20072 continuation glyph before the right margin. If lines are
20073 continued, there are two possible strategies for characters
20074 resulting in more than 1 glyph (e.g. tabs): Display as many
20075 glyphs as possible in this line and leave the rest for the
20076 continuation line, or display the whole element in the next
20077 line. Original redisplay did the former, so we do it also. */
20078 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
20079 hpos_before
= it
->hpos
;
20082 if (/* Not a newline. */
20084 /* Glyphs produced fit entirely in the line. */
20085 && it
->current_x
< it
->last_visible_x
)
20087 it
->hpos
+= nglyphs
;
20088 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
20089 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
20090 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
20091 row
->phys_height
= max (row
->phys_height
,
20092 it
->max_phys_ascent
+ it
->max_phys_descent
);
20093 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
20094 it
->max_extra_line_spacing
);
20095 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
20096 row
->x
= x
- it
->first_visible_x
;
20097 /* Record the maximum and minimum buffer positions seen so
20098 far in glyphs that will be displayed by this row. */
20100 RECORD_MAX_MIN_POS (it
);
20105 struct glyph
*glyph
;
20107 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
20109 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
20110 new_x
= x
+ glyph
->pixel_width
;
20112 if (/* Lines are continued. */
20113 it
->line_wrap
!= TRUNCATE
20114 && (/* Glyph doesn't fit on the line. */
20115 new_x
> it
->last_visible_x
20116 /* Or it fits exactly on a window system frame. */
20117 || (new_x
== it
->last_visible_x
20118 && FRAME_WINDOW_P (it
->f
)
20119 && (row
->reversed_p
20120 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
20121 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
20123 /* End of a continued line. */
20126 || (new_x
== it
->last_visible_x
20127 && FRAME_WINDOW_P (it
->f
)
20128 && (row
->reversed_p
20129 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
20130 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
))))
20132 /* Current glyph is the only one on the line or
20133 fits exactly on the line. We must continue
20134 the line because we can't draw the cursor
20135 after the glyph. */
20136 row
->continued_p
= 1;
20137 it
->current_x
= new_x
;
20138 it
->continuation_lines_width
+= new_x
;
20140 if (i
== nglyphs
- 1)
20142 /* If line-wrap is on, check if a previous
20143 wrap point was found. */
20144 if (wrap_row_used
> 0
20145 /* Even if there is a previous wrap
20146 point, continue the line here as
20147 usual, if (i) the previous character
20148 was a space or tab AND (ii) the
20149 current character is not. */
20151 || IT_DISPLAYING_WHITESPACE (it
)))
20154 /* Record the maximum and minimum buffer
20155 positions seen so far in glyphs that will be
20156 displayed by this row. */
20158 RECORD_MAX_MIN_POS (it
);
20159 set_iterator_to_next (it
, 1);
20160 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
20162 if (!get_next_display_element (it
))
20164 row
->exact_window_width_line_p
= 1;
20165 it
->continuation_lines_width
= 0;
20166 row
->continued_p
= 0;
20167 row
->ends_at_zv_p
= 1;
20169 else if (ITERATOR_AT_END_OF_LINE_P (it
))
20171 row
->continued_p
= 0;
20172 row
->exact_window_width_line_p
= 1;
20176 else if (it
->bidi_p
)
20177 RECORD_MAX_MIN_POS (it
);
20178 if (WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
20179 || WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0)
20180 extend_face_to_end_of_line (it
);
20182 else if (CHAR_GLYPH_PADDING_P (*glyph
)
20183 && !FRAME_WINDOW_P (it
->f
))
20185 /* A padding glyph that doesn't fit on this line.
20186 This means the whole character doesn't fit
20188 if (row
->reversed_p
)
20189 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
20190 - n_glyphs_before
);
20191 row
->used
[TEXT_AREA
] = n_glyphs_before
;
20193 /* Fill the rest of the row with continuation
20194 glyphs like in 20.x. */
20195 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
20196 < row
->glyphs
[1 + TEXT_AREA
])
20197 produce_special_glyphs (it
, IT_CONTINUATION
);
20199 row
->continued_p
= 1;
20200 it
->current_x
= x_before
;
20201 it
->continuation_lines_width
+= x_before
;
20203 /* Restore the height to what it was before the
20204 element not fitting on the line. */
20205 it
->max_ascent
= ascent
;
20206 it
->max_descent
= descent
;
20207 it
->max_phys_ascent
= phys_ascent
;
20208 it
->max_phys_descent
= phys_descent
;
20209 if (WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
20210 || WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0)
20211 extend_face_to_end_of_line (it
);
20213 else if (wrap_row_used
> 0)
20216 if (row
->reversed_p
)
20217 unproduce_glyphs (it
,
20218 row
->used
[TEXT_AREA
] - wrap_row_used
);
20219 RESTORE_IT (it
, &wrap_it
, wrap_data
);
20220 it
->continuation_lines_width
+= wrap_x
;
20221 row
->used
[TEXT_AREA
] = wrap_row_used
;
20222 row
->ascent
= wrap_row_ascent
;
20223 row
->height
= wrap_row_height
;
20224 row
->phys_ascent
= wrap_row_phys_ascent
;
20225 row
->phys_height
= wrap_row_phys_height
;
20226 row
->extra_line_spacing
= wrap_row_extra_line_spacing
;
20227 min_pos
= wrap_row_min_pos
;
20228 min_bpos
= wrap_row_min_bpos
;
20229 max_pos
= wrap_row_max_pos
;
20230 max_bpos
= wrap_row_max_bpos
;
20231 row
->continued_p
= 1;
20232 row
->ends_at_zv_p
= 0;
20233 row
->exact_window_width_line_p
= 0;
20234 it
->continuation_lines_width
+= x
;
20236 /* Make sure that a non-default face is extended
20237 up to the right margin of the window. */
20238 extend_face_to_end_of_line (it
);
20240 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
20242 /* A TAB that extends past the right edge of the
20243 window. This produces a single glyph on
20244 window system frames. We leave the glyph in
20245 this row and let it fill the row, but don't
20246 consume the TAB. */
20247 if ((row
->reversed_p
20248 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
20249 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
20250 produce_special_glyphs (it
, IT_CONTINUATION
);
20251 it
->continuation_lines_width
+= it
->last_visible_x
;
20252 row
->ends_in_middle_of_char_p
= 1;
20253 row
->continued_p
= 1;
20254 glyph
->pixel_width
= it
->last_visible_x
- x
;
20255 it
->starts_in_middle_of_char_p
= 1;
20256 if (WINDOW_LEFT_MARGIN_WIDTH (it
->w
) > 0
20257 || WINDOW_RIGHT_MARGIN_WIDTH (it
->w
) > 0)
20258 extend_face_to_end_of_line (it
);
20262 /* Something other than a TAB that draws past
20263 the right edge of the window. Restore
20264 positions to values before the element. */
20265 if (row
->reversed_p
)
20266 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
20267 - (n_glyphs_before
+ i
));
20268 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
20270 /* Display continuation glyphs. */
20271 it
->current_x
= x_before
;
20272 it
->continuation_lines_width
+= x
;
20273 if (!FRAME_WINDOW_P (it
->f
)
20274 || (row
->reversed_p
20275 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
20276 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
20277 produce_special_glyphs (it
, IT_CONTINUATION
);
20278 row
->continued_p
= 1;
20280 extend_face_to_end_of_line (it
);
20282 if (nglyphs
> 1 && i
> 0)
20284 row
->ends_in_middle_of_char_p
= 1;
20285 it
->starts_in_middle_of_char_p
= 1;
20288 /* Restore the height to what it was before the
20289 element not fitting on the line. */
20290 it
->max_ascent
= ascent
;
20291 it
->max_descent
= descent
;
20292 it
->max_phys_ascent
= phys_ascent
;
20293 it
->max_phys_descent
= phys_descent
;
20298 else if (new_x
> it
->first_visible_x
)
20300 /* Increment number of glyphs actually displayed. */
20303 /* Record the maximum and minimum buffer positions
20304 seen so far in glyphs that will be displayed by
20307 RECORD_MAX_MIN_POS (it
);
20309 if (x
< it
->first_visible_x
)
20310 /* Glyph is partially visible, i.e. row starts at
20311 negative X position. */
20312 row
->x
= x
- it
->first_visible_x
;
20316 /* Glyph is completely off the left margin of the
20317 window. This should not happen because of the
20318 move_it_in_display_line at the start of this
20319 function, unless the text display area of the
20320 window is empty. */
20321 eassert (it
->first_visible_x
<= it
->last_visible_x
);
20324 /* Even if this display element produced no glyphs at all,
20325 we want to record its position. */
20326 if (it
->bidi_p
&& nglyphs
== 0)
20327 RECORD_MAX_MIN_POS (it
);
20329 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
20330 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
20331 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
20332 row
->phys_height
= max (row
->phys_height
,
20333 it
->max_phys_ascent
+ it
->max_phys_descent
);
20334 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
20335 it
->max_extra_line_spacing
);
20337 /* End of this display line if row is continued. */
20338 if (row
->continued_p
|| row
->ends_at_zv_p
)
20343 /* Is this a line end? If yes, we're also done, after making
20344 sure that a non-default face is extended up to the right
20345 margin of the window. */
20346 if (ITERATOR_AT_END_OF_LINE_P (it
))
20348 int used_before
= row
->used
[TEXT_AREA
];
20350 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
20352 /* Add a space at the end of the line that is used to
20353 display the cursor there. */
20354 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
20355 append_space_for_newline (it
, 0);
20357 /* Extend the face to the end of the line. */
20358 extend_face_to_end_of_line (it
);
20360 /* Make sure we have the position. */
20361 if (used_before
== 0)
20362 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
20364 /* Record the position of the newline, for use in
20366 it
->eol_pos
= it
->current
.pos
;
20368 /* Consume the line end. This skips over invisible lines. */
20369 set_iterator_to_next (it
, 1);
20370 it
->continuation_lines_width
= 0;
20374 /* Proceed with next display element. Note that this skips
20375 over lines invisible because of selective display. */
20376 set_iterator_to_next (it
, 1);
20378 /* If we truncate lines, we are done when the last displayed
20379 glyphs reach past the right margin of the window. */
20380 if (it
->line_wrap
== TRUNCATE
20381 && ((FRAME_WINDOW_P (it
->f
)
20382 /* Images are preprocessed in produce_image_glyph such
20383 that they are cropped at the right edge of the
20384 window, so an image glyph will always end exactly at
20385 last_visible_x, even if there's no right fringe. */
20386 && (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) || it
->what
== IT_IMAGE
))
20387 ? (it
->current_x
>= it
->last_visible_x
)
20388 : (it
->current_x
> it
->last_visible_x
)))
20390 /* Maybe add truncation glyphs. */
20391 if (!FRAME_WINDOW_P (it
->f
)
20392 || (row
->reversed_p
20393 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
20394 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
20398 if (!row
->reversed_p
)
20400 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
20401 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
20406 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
20407 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
20409 /* Remove any padding glyphs at the front of ROW, to
20410 make room for the truncation glyphs we will be
20411 adding below. The loop below always inserts at
20412 least one truncation glyph, so also remove the
20413 last glyph added to ROW. */
20414 unproduce_glyphs (it
, i
+ 1);
20415 /* Adjust i for the loop below. */
20416 i
= row
->used
[TEXT_AREA
] - (i
+ 1);
20419 /* produce_special_glyphs overwrites the last glyph, so
20420 we don't want that if we want to keep that last
20421 glyph, which means it's an image. */
20422 if (it
->current_x
> it
->last_visible_x
)
20424 it
->current_x
= x_before
;
20425 if (!FRAME_WINDOW_P (it
->f
))
20427 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
20429 row
->used
[TEXT_AREA
] = i
;
20430 produce_special_glyphs (it
, IT_TRUNCATION
);
20435 row
->used
[TEXT_AREA
] = i
;
20436 produce_special_glyphs (it
, IT_TRUNCATION
);
20438 it
->hpos
= hpos_before
;
20441 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
20443 /* Don't truncate if we can overflow newline into fringe. */
20444 if (!get_next_display_element (it
))
20446 it
->continuation_lines_width
= 0;
20447 row
->ends_at_zv_p
= 1;
20448 row
->exact_window_width_line_p
= 1;
20451 if (ITERATOR_AT_END_OF_LINE_P (it
))
20453 row
->exact_window_width_line_p
= 1;
20454 goto at_end_of_line
;
20456 it
->current_x
= x_before
;
20457 it
->hpos
= hpos_before
;
20460 row
->truncated_on_right_p
= 1;
20461 it
->continuation_lines_width
= 0;
20462 reseat_at_next_visible_line_start (it
, 0);
20463 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
20469 bidi_unshelve_cache (wrap_data
, 1);
20471 /* If line is not empty and hscrolled, maybe insert truncation glyphs
20472 at the left window margin. */
20473 if (it
->first_visible_x
20474 && IT_CHARPOS (*it
) != CHARPOS (row
->start
.pos
))
20476 if (!FRAME_WINDOW_P (it
->f
)
20477 || (((row
->reversed_p
20478 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
20479 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
20480 /* Don't let insert_left_trunc_glyphs overwrite the
20481 first glyph of the row if it is an image. */
20482 && row
->glyphs
[TEXT_AREA
]->type
!= IMAGE_GLYPH
))
20483 insert_left_trunc_glyphs (it
);
20484 row
->truncated_on_left_p
= 1;
20487 /* Remember the position at which this line ends.
20489 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
20490 cannot be before the call to find_row_edges below, since that is
20491 where these positions are determined. */
20492 row
->end
= it
->current
;
20495 row
->minpos
= row
->start
.pos
;
20496 row
->maxpos
= row
->end
.pos
;
20500 /* ROW->minpos and ROW->maxpos must be the smallest and
20501 `1 + the largest' buffer positions in ROW. But if ROW was
20502 bidi-reordered, these two positions can be anywhere in the
20503 row, so we must determine them now. */
20504 find_row_edges (it
, row
, min_pos
, min_bpos
, max_pos
, max_bpos
);
20507 /* If the start of this line is the overlay arrow-position, then
20508 mark this glyph row as the one containing the overlay arrow.
20509 This is clearly a mess with variable size fonts. It would be
20510 better to let it be displayed like cursors under X. */
20511 if ((MATRIX_ROW_DISPLAYS_TEXT_P (row
) || !overlay_arrow_seen
)
20512 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
20513 !NILP (overlay_arrow_string
)))
20515 /* Overlay arrow in window redisplay is a fringe bitmap. */
20516 if (STRINGP (overlay_arrow_string
))
20518 struct glyph_row
*arrow_row
20519 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
20520 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
20521 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
20522 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
20523 struct glyph
*p2
, *end
;
20525 /* Copy the arrow glyphs. */
20526 while (glyph
< arrow_end
)
20529 /* Throw away padding glyphs. */
20531 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
20532 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
20538 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
20543 eassert (INTEGERP (overlay_arrow_string
));
20544 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
20546 overlay_arrow_seen
= 1;
20549 /* Highlight trailing whitespace. */
20550 if (!NILP (Vshow_trailing_whitespace
))
20551 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
20553 /* Compute pixel dimensions of this line. */
20554 compute_line_metrics (it
);
20556 /* Implementation note: No changes in the glyphs of ROW or in their
20557 faces can be done past this point, because compute_line_metrics
20558 computes ROW's hash value and stores it within the glyph_row
20561 /* Record whether this row ends inside an ellipsis. */
20562 row
->ends_in_ellipsis_p
20563 = (it
->method
== GET_FROM_DISPLAY_VECTOR
20564 && it
->ellipsis_p
);
20566 /* Save fringe bitmaps in this row. */
20567 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
20568 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
20569 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
20570 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
20572 it
->left_user_fringe_bitmap
= 0;
20573 it
->left_user_fringe_face_id
= 0;
20574 it
->right_user_fringe_bitmap
= 0;
20575 it
->right_user_fringe_face_id
= 0;
20577 /* Maybe set the cursor. */
20578 cvpos
= it
->w
->cursor
.vpos
;
20580 /* In bidi-reordered rows, keep checking for proper cursor
20581 position even if one has been found already, because buffer
20582 positions in such rows change non-linearly with ROW->VPOS,
20583 when a line is continued. One exception: when we are at ZV,
20584 display cursor on the first suitable glyph row, since all
20585 the empty rows after that also have their position set to ZV. */
20586 /* FIXME: Revisit this when glyph ``spilling'' in continuation
20587 lines' rows is implemented for bidi-reordered rows. */
20589 && !MATRIX_ROW (it
->w
->desired_matrix
, cvpos
)->ends_at_zv_p
))
20590 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
20591 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
20592 && cursor_row_p (row
))
20593 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
20595 /* Prepare for the next line. This line starts horizontally at (X
20596 HPOS) = (0 0). Vertical positions are incremented. As a
20597 convenience for the caller, IT->glyph_row is set to the next
20599 it
->current_x
= it
->hpos
= 0;
20600 it
->current_y
+= row
->height
;
20601 SET_TEXT_POS (it
->eol_pos
, 0, 0);
20604 /* The next row should by default use the same value of the
20605 reversed_p flag as this one. set_iterator_to_next decides when
20606 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
20607 the flag accordingly. */
20608 if (it
->glyph_row
< MATRIX_BOTTOM_TEXT_ROW (it
->w
->desired_matrix
, it
->w
))
20609 it
->glyph_row
->reversed_p
= row
->reversed_p
;
20610 it
->start
= row
->end
;
20611 return MATRIX_ROW_DISPLAYS_TEXT_P (row
);
20613 #undef RECORD_MAX_MIN_POS
20616 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction
,
20617 Scurrent_bidi_paragraph_direction
, 0, 1, 0,
20618 doc
: /* Return paragraph direction at point in BUFFER.
20619 Value is either `left-to-right' or `right-to-left'.
20620 If BUFFER is omitted or nil, it defaults to the current buffer.
20622 Paragraph direction determines how the text in the paragraph is displayed.
20623 In left-to-right paragraphs, text begins at the left margin of the window
20624 and the reading direction is generally left to right. In right-to-left
20625 paragraphs, text begins at the right margin and is read from right to left.
20627 See also `bidi-paragraph-direction'. */)
20628 (Lisp_Object buffer
)
20630 struct buffer
*buf
= current_buffer
;
20631 struct buffer
*old
= buf
;
20633 if (! NILP (buffer
))
20635 CHECK_BUFFER (buffer
);
20636 buf
= XBUFFER (buffer
);
20639 if (NILP (BVAR (buf
, bidi_display_reordering
))
20640 || NILP (BVAR (buf
, enable_multibyte_characters
))
20641 /* When we are loading loadup.el, the character property tables
20642 needed for bidi iteration are not yet available. */
20643 || !NILP (Vpurify_flag
))
20644 return Qleft_to_right
;
20645 else if (!NILP (BVAR (buf
, bidi_paragraph_direction
)))
20646 return BVAR (buf
, bidi_paragraph_direction
);
20649 /* Determine the direction from buffer text. We could try to
20650 use current_matrix if it is up to date, but this seems fast
20651 enough as it is. */
20652 struct bidi_it itb
;
20653 ptrdiff_t pos
= BUF_PT (buf
);
20654 ptrdiff_t bytepos
= BUF_PT_BYTE (buf
);
20656 void *itb_data
= bidi_shelve_cache ();
20658 set_buffer_temp (buf
);
20659 /* bidi_paragraph_init finds the base direction of the paragraph
20660 by searching forward from paragraph start. We need the base
20661 direction of the current or _previous_ paragraph, so we need
20662 to make sure we are within that paragraph. To that end, find
20663 the previous non-empty line. */
20664 if (pos
>= ZV
&& pos
> BEGV
)
20665 DEC_BOTH (pos
, bytepos
);
20666 if (fast_looking_at (build_string ("[\f\t ]*\n"),
20667 pos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) > 0)
20669 while ((c
= FETCH_BYTE (bytepos
)) == '\n'
20670 || c
== ' ' || c
== '\t' || c
== '\f')
20672 if (bytepos
<= BEGV_BYTE
)
20677 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos
)))
20680 bidi_init_it (pos
, bytepos
, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb
);
20681 itb
.paragraph_dir
= NEUTRAL_DIR
;
20682 itb
.string
.s
= NULL
;
20683 itb
.string
.lstring
= Qnil
;
20684 itb
.string
.bufpos
= 0;
20685 itb
.string
.from_disp_str
= 0;
20686 itb
.string
.unibyte
= 0;
20687 /* We have no window to use here for ignoring window-specific
20688 overlays. Using NULL for window pointer will cause
20689 compute_display_string_pos to use the current buffer. */
20691 bidi_paragraph_init (NEUTRAL_DIR
, &itb
, 1);
20692 bidi_unshelve_cache (itb_data
, 0);
20693 set_buffer_temp (old
);
20694 switch (itb
.paragraph_dir
)
20697 return Qleft_to_right
;
20700 return Qright_to_left
;
20708 DEFUN ("move-point-visually", Fmove_point_visually
,
20709 Smove_point_visually
, 1, 1, 0,
20710 doc
: /* Move point in the visual order in the specified DIRECTION.
20711 DIRECTION can be 1, meaning move to the right, or -1, which moves to the
20714 Value is the new character position of point. */)
20715 (Lisp_Object direction
)
20717 struct window
*w
= XWINDOW (selected_window
);
20718 struct buffer
*b
= XBUFFER (w
->contents
);
20719 struct glyph_row
*row
;
20721 Lisp_Object paragraph_dir
;
20723 #define ROW_GLYPH_NEWLINE_P(ROW,GLYPH) \
20724 (!(ROW)->continued_p \
20725 && INTEGERP ((GLYPH)->object) \
20726 && (GLYPH)->type == CHAR_GLYPH \
20727 && (GLYPH)->u.ch == ' ' \
20728 && (GLYPH)->charpos >= 0 \
20729 && !(GLYPH)->avoid_cursor_p)
20731 CHECK_NUMBER (direction
);
20732 dir
= XINT (direction
);
20738 /* If current matrix is up-to-date, we can use the information
20739 recorded in the glyphs, at least as long as the goal is on the
20741 if (w
->window_end_valid
20742 && !windows_or_buffers_changed
20744 && !b
->clip_changed
20745 && !b
->prevent_redisplay_optimizations_p
20746 && !window_outdated (w
)
20747 /* We rely below on the cursor coordinates to be up to date, but
20748 we cannot trust them if some command moved point since the
20749 last complete redisplay. */
20750 && w
->last_point
== BUF_PT (b
)
20751 && w
->cursor
.vpos
>= 0
20752 && w
->cursor
.vpos
< w
->current_matrix
->nrows
20753 && (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
))->enabled_p
)
20755 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
20756 struct glyph
*e
= dir
> 0 ? g
+ row
->used
[TEXT_AREA
] : g
- 1;
20757 struct glyph
*gpt
= g
+ w
->cursor
.hpos
;
20759 for (g
= gpt
+ dir
; (dir
> 0 ? g
< e
: g
> e
); g
+= dir
)
20761 if (BUFFERP (g
->object
) && g
->charpos
!= PT
)
20763 SET_PT (g
->charpos
);
20764 w
->cursor
.vpos
= -1;
20765 return make_number (PT
);
20767 else if (!INTEGERP (g
->object
) && !EQ (g
->object
, gpt
->object
))
20771 if (BUFFERP (gpt
->object
))
20774 if ((gpt
->resolved_level
- row
->reversed_p
) % 2 == 0)
20775 new_pos
+= (row
->reversed_p
? -dir
: dir
);
20777 new_pos
-= (row
->reversed_p
? -dir
: dir
);;
20779 else if (BUFFERP (g
->object
))
20780 new_pos
= g
->charpos
;
20784 w
->cursor
.vpos
= -1;
20785 return make_number (PT
);
20787 else if (ROW_GLYPH_NEWLINE_P (row
, g
))
20789 /* Glyphs inserted at the end of a non-empty line for
20790 positioning the cursor have zero charpos, so we must
20791 deduce the value of point by other means. */
20792 if (g
->charpos
> 0)
20793 SET_PT (g
->charpos
);
20794 else if (row
->ends_at_zv_p
&& PT
!= ZV
)
20796 else if (PT
!= MATRIX_ROW_END_CHARPOS (row
) - 1)
20797 SET_PT (MATRIX_ROW_END_CHARPOS (row
) - 1);
20800 w
->cursor
.vpos
= -1;
20801 return make_number (PT
);
20804 if (g
== e
|| INTEGERP (g
->object
))
20806 if (row
->truncated_on_left_p
|| row
->truncated_on_right_p
)
20807 goto simulate_display
;
20808 if (!row
->reversed_p
)
20812 if (row
< MATRIX_FIRST_TEXT_ROW (w
->current_matrix
)
20813 || row
> MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
20814 goto simulate_display
;
20818 if (row
->reversed_p
&& !row
->continued_p
)
20820 SET_PT (MATRIX_ROW_END_CHARPOS (row
) - 1);
20821 w
->cursor
.vpos
= -1;
20822 return make_number (PT
);
20824 g
= row
->glyphs
[TEXT_AREA
];
20825 e
= g
+ row
->used
[TEXT_AREA
];
20826 for ( ; g
< e
; g
++)
20828 if (BUFFERP (g
->object
)
20829 /* Empty lines have only one glyph, which stands
20830 for the newline, and whose charpos is the
20831 buffer position of the newline. */
20832 || ROW_GLYPH_NEWLINE_P (row
, g
)
20833 /* When the buffer ends in a newline, the line at
20834 EOB also has one glyph, but its charpos is -1. */
20835 || (row
->ends_at_zv_p
20836 && !row
->reversed_p
20837 && INTEGERP (g
->object
)
20838 && g
->type
== CHAR_GLYPH
20839 && g
->u
.ch
== ' '))
20841 if (g
->charpos
> 0)
20842 SET_PT (g
->charpos
);
20843 else if (!row
->reversed_p
20844 && row
->ends_at_zv_p
20849 w
->cursor
.vpos
= -1;
20850 return make_number (PT
);
20856 if (!row
->reversed_p
&& !row
->continued_p
)
20858 SET_PT (MATRIX_ROW_END_CHARPOS (row
) - 1);
20859 w
->cursor
.vpos
= -1;
20860 return make_number (PT
);
20862 e
= row
->glyphs
[TEXT_AREA
];
20863 g
= e
+ row
->used
[TEXT_AREA
] - 1;
20864 for ( ; g
>= e
; g
--)
20866 if (BUFFERP (g
->object
)
20867 || (ROW_GLYPH_NEWLINE_P (row
, g
)
20869 /* Empty R2L lines on GUI frames have the buffer
20870 position of the newline stored in the stretch
20872 || g
->type
== STRETCH_GLYPH
20873 || (row
->ends_at_zv_p
20875 && INTEGERP (g
->object
)
20876 && g
->type
== CHAR_GLYPH
20877 && g
->u
.ch
== ' '))
20879 if (g
->charpos
> 0)
20880 SET_PT (g
->charpos
);
20881 else if (row
->reversed_p
20882 && row
->ends_at_zv_p
20887 w
->cursor
.vpos
= -1;
20888 return make_number (PT
);
20897 /* If we wind up here, we failed to move by using the glyphs, so we
20898 need to simulate display instead. */
20901 paragraph_dir
= Fcurrent_bidi_paragraph_direction (w
->contents
);
20903 paragraph_dir
= Qleft_to_right
;
20904 if (EQ (paragraph_dir
, Qright_to_left
))
20906 if (PT
<= BEGV
&& dir
< 0)
20907 xsignal0 (Qbeginning_of_buffer
);
20908 else if (PT
>= ZV
&& dir
> 0)
20909 xsignal0 (Qend_of_buffer
);
20912 struct text_pos pt
;
20914 int pt_x
, target_x
, pixel_width
, pt_vpos
;
20916 bool overshoot_expected
= false;
20917 bool target_is_eol_p
= false;
20919 /* Setup the arena. */
20920 SET_TEXT_POS (pt
, PT
, PT_BYTE
);
20921 start_display (&it
, w
, pt
);
20923 if (it
.cmp_it
.id
< 0
20924 && it
.method
== GET_FROM_STRING
20925 && it
.area
== TEXT_AREA
20926 && it
.string_from_display_prop_p
20927 && (it
.sp
> 0 && it
.stack
[it
.sp
- 1].method
== GET_FROM_BUFFER
))
20928 overshoot_expected
= true;
20930 /* Find the X coordinate of point. We start from the beginning
20931 of this or previous line to make sure we are before point in
20932 the logical order (since the move_it_* functions can only
20935 reseat_at_previous_visible_line_start (&it
);
20936 it
.current_x
= it
.hpos
= it
.current_y
= it
.vpos
= 0;
20937 if (IT_CHARPOS (it
) != PT
)
20939 move_it_to (&it
, overshoot_expected
? PT
- 1 : PT
,
20940 -1, -1, -1, MOVE_TO_POS
);
20941 /* If we missed point because the character there is
20942 displayed out of a display vector that has more than one
20943 glyph, retry expecting overshoot. */
20944 if (it
.method
== GET_FROM_DISPLAY_VECTOR
20945 && it
.current
.dpvec_index
> 0
20946 && !overshoot_expected
)
20948 overshoot_expected
= true;
20951 else if (IT_CHARPOS (it
) != PT
&& !overshoot_expected
)
20952 move_it_in_display_line (&it
, PT
, -1, MOVE_TO_POS
);
20954 pt_x
= it
.current_x
;
20956 if (dir
> 0 || overshoot_expected
)
20958 struct glyph_row
*row
= it
.glyph_row
;
20960 /* When point is at beginning of line, we don't have
20961 information about the glyph there loaded into struct
20962 it. Calling get_next_display_element fixes that. */
20964 get_next_display_element (&it
);
20965 at_eol_p
= ITERATOR_AT_END_OF_LINE_P (&it
);
20966 it
.glyph_row
= NULL
;
20967 PRODUCE_GLYPHS (&it
); /* compute it.pixel_width */
20968 it
.glyph_row
= row
;
20969 /* PRODUCE_GLYPHS advances it.current_x, so we must restore
20970 it, lest it will become out of sync with it's buffer
20972 it
.current_x
= pt_x
;
20975 at_eol_p
= ITERATOR_AT_END_OF_LINE_P (&it
);
20976 pixel_width
= it
.pixel_width
;
20977 if (overshoot_expected
&& at_eol_p
)
20979 else if (pixel_width
<= 0)
20982 /* If there's a display string (or something similar) at point,
20983 we are actually at the glyph to the left of point, so we need
20984 to correct the X coordinate. */
20985 if (overshoot_expected
)
20988 pt_x
+= pixel_width
* it
.bidi_it
.scan_dir
;
20990 pt_x
+= pixel_width
;
20993 /* Compute target X coordinate, either to the left or to the
20994 right of point. On TTY frames, all characters have the same
20995 pixel width of 1, so we can use that. On GUI frames we don't
20996 have an easy way of getting at the pixel width of the
20997 character to the left of point, so we use a different method
20998 of getting to that place. */
21000 target_x
= pt_x
+ pixel_width
;
21002 target_x
= pt_x
- (!FRAME_WINDOW_P (it
.f
)) * pixel_width
;
21004 /* Target X coordinate could be one line above or below the line
21005 of point, in which case we need to adjust the target X
21006 coordinate. Also, if moving to the left, we need to begin at
21007 the left edge of the point's screen line. */
21012 start_display (&it
, w
, pt
);
21013 reseat_at_previous_visible_line_start (&it
);
21014 it
.current_x
= it
.current_y
= it
.hpos
= 0;
21016 move_it_by_lines (&it
, pt_vpos
);
21020 move_it_by_lines (&it
, -1);
21021 target_x
= it
.last_visible_x
- !FRAME_WINDOW_P (it
.f
);
21022 target_is_eol_p
= true;
21023 /* Under word-wrap, we don't know the x coordinate of
21024 the last character displayed on the previous line,
21025 which immediately precedes the wrap point. To find
21026 out its x coordinate, we try moving to the right
21027 margin of the window, which will stop at the wrap
21028 point, and then reset target_x to point at the
21029 character that precedes the wrap point. This is not
21030 needed on GUI frames, because (see below) there we
21031 move from the left margin one grapheme cluster at a
21032 time, and stop when we hit the wrap point. */
21033 if (!FRAME_WINDOW_P (it
.f
) && it
.line_wrap
== WORD_WRAP
)
21035 void *it_data
= NULL
;
21038 SAVE_IT (it2
, it
, it_data
);
21039 move_it_in_display_line_to (&it
, ZV
, target_x
,
21040 MOVE_TO_POS
| MOVE_TO_X
);
21041 /* If we arrived at target_x, that _is_ the last
21042 character on the previous line. */
21043 if (it
.current_x
!= target_x
)
21044 target_x
= it
.current_x
- 1;
21045 RESTORE_IT (&it
, &it2
, it_data
);
21052 || (target_x
>= it
.last_visible_x
21053 && it
.line_wrap
!= TRUNCATE
))
21056 move_it_by_lines (&it
, 0);
21057 move_it_by_lines (&it
, 1);
21062 /* Move to the target X coordinate. */
21063 #ifdef HAVE_WINDOW_SYSTEM
21064 /* On GUI frames, as we don't know the X coordinate of the
21065 character to the left of point, moving point to the left
21066 requires walking, one grapheme cluster at a time, until we
21067 find ourself at a place immediately to the left of the
21068 character at point. */
21069 if (FRAME_WINDOW_P (it
.f
) && dir
< 0)
21071 struct text_pos new_pos
;
21072 enum move_it_result rc
= MOVE_X_REACHED
;
21074 if (it
.current_x
== 0)
21075 get_next_display_element (&it
);
21076 if (it
.what
== IT_COMPOSITION
)
21078 new_pos
.charpos
= it
.cmp_it
.charpos
;
21079 new_pos
.bytepos
= -1;
21082 new_pos
= it
.current
.pos
;
21084 while (it
.current_x
+ it
.pixel_width
<= target_x
21085 && (rc
== MOVE_X_REACHED
21086 /* Under word-wrap, move_it_in_display_line_to
21087 stops at correct coordinates, but sometimes
21088 returns MOVE_POS_MATCH_OR_ZV. */
21089 || (it
.line_wrap
== WORD_WRAP
21090 && rc
== MOVE_POS_MATCH_OR_ZV
)))
21092 int new_x
= it
.current_x
+ it
.pixel_width
;
21094 /* For composed characters, we want the position of the
21095 first character in the grapheme cluster (usually, the
21096 composition's base character), whereas it.current
21097 might give us the position of the _last_ one, e.g. if
21098 the composition is rendered in reverse due to bidi
21100 if (it
.what
== IT_COMPOSITION
)
21102 new_pos
.charpos
= it
.cmp_it
.charpos
;
21103 new_pos
.bytepos
= -1;
21106 new_pos
= it
.current
.pos
;
21107 if (new_x
== it
.current_x
)
21109 rc
= move_it_in_display_line_to (&it
, ZV
, new_x
,
21110 MOVE_TO_POS
| MOVE_TO_X
);
21111 if (ITERATOR_AT_END_OF_LINE_P (&it
) && !target_is_eol_p
)
21114 /* The previous position we saw in the loop is the one we
21116 if (new_pos
.bytepos
== -1)
21117 new_pos
.bytepos
= CHAR_TO_BYTE (new_pos
.charpos
);
21118 it
.current
.pos
= new_pos
;
21122 if (it
.current_x
!= target_x
)
21123 move_it_in_display_line_to (&it
, ZV
, target_x
, MOVE_TO_POS
| MOVE_TO_X
);
21125 /* When lines are truncated, the above loop will stop at the
21126 window edge. But we want to get to the end of line, even if
21127 it is beyond the window edge; automatic hscroll will then
21128 scroll the window to show point as appropriate. */
21129 if (target_is_eol_p
&& it
.line_wrap
== TRUNCATE
21130 && get_next_display_element (&it
))
21132 struct text_pos new_pos
= it
.current
.pos
;
21134 while (!ITERATOR_AT_END_OF_LINE_P (&it
))
21136 set_iterator_to_next (&it
, 0);
21137 if (it
.method
== GET_FROM_BUFFER
)
21138 new_pos
= it
.current
.pos
;
21139 if (!get_next_display_element (&it
))
21143 it
.current
.pos
= new_pos
;
21146 /* If we ended up in a display string that covers point, move to
21147 buffer position to the right in the visual order. */
21150 while (IT_CHARPOS (it
) == PT
)
21152 set_iterator_to_next (&it
, 0);
21153 if (!get_next_display_element (&it
))
21158 /* Move point to that position. */
21159 SET_PT_BOTH (IT_CHARPOS (it
), IT_BYTEPOS (it
));
21162 return make_number (PT
);
21164 #undef ROW_GLYPH_NEWLINE_P
21168 /***********************************************************************
21170 ***********************************************************************/
21172 /* Redisplay the menu bar in the frame for window W.
21174 The menu bar of X frames that don't have X toolkit support is
21175 displayed in a special window W->frame->menu_bar_window.
21177 The menu bar of terminal frames is treated specially as far as
21178 glyph matrices are concerned. Menu bar lines are not part of
21179 windows, so the update is done directly on the frame matrix rows
21180 for the menu bar. */
21183 display_menu_bar (struct window
*w
)
21185 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
21190 /* Don't do all this for graphical frames. */
21192 if (FRAME_W32_P (f
))
21195 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
21201 if (FRAME_NS_P (f
))
21203 #endif /* HAVE_NS */
21205 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
21206 eassert (!FRAME_WINDOW_P (f
));
21207 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
21208 it
.first_visible_x
= 0;
21209 it
.last_visible_x
= FRAME_PIXEL_WIDTH (f
);
21210 #elif defined (HAVE_X_WINDOWS) /* X without toolkit. */
21211 if (FRAME_WINDOW_P (f
))
21213 /* Menu bar lines are displayed in the desired matrix of the
21214 dummy window menu_bar_window. */
21215 struct window
*menu_w
;
21216 menu_w
= XWINDOW (f
->menu_bar_window
);
21217 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
21219 it
.first_visible_x
= 0;
21220 it
.last_visible_x
= FRAME_PIXEL_WIDTH (f
);
21223 #endif /* not USE_X_TOOLKIT and not USE_GTK */
21225 /* This is a TTY frame, i.e. character hpos/vpos are used as
21227 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
21229 it
.first_visible_x
= 0;
21230 it
.last_visible_x
= FRAME_COLS (f
);
21233 /* FIXME: This should be controlled by a user option. See the
21234 comments in redisplay_tool_bar and display_mode_line about
21236 it
.paragraph_embedding
= L2R
;
21238 /* Clear all rows of the menu bar. */
21239 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
21241 struct glyph_row
*row
= it
.glyph_row
+ i
;
21242 clear_glyph_row (row
);
21243 row
->enabled_p
= true;
21244 row
->full_width_p
= 1;
21247 /* Display all items of the menu bar. */
21248 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
21249 for (i
= 0; i
< ASIZE (items
); i
+= 4)
21251 Lisp_Object string
;
21253 /* Stop at nil string. */
21254 string
= AREF (items
, i
+ 1);
21258 /* Remember where item was displayed. */
21259 ASET (items
, i
+ 3, make_number (it
.hpos
));
21261 /* Display the item, pad with one space. */
21262 if (it
.current_x
< it
.last_visible_x
)
21263 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
21264 SCHARS (string
) + 1, 0, 0, -1);
21267 /* Fill out the line with spaces. */
21268 if (it
.current_x
< it
.last_visible_x
)
21269 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
21271 /* Compute the total height of the lines. */
21272 compute_line_metrics (&it
);
21275 /* Deep copy of a glyph row, including the glyphs. */
21277 deep_copy_glyph_row (struct glyph_row
*to
, struct glyph_row
*from
)
21279 struct glyph
*pointers
[1 + LAST_AREA
];
21280 int to_used
= to
->used
[TEXT_AREA
];
21282 /* Save glyph pointers of TO. */
21283 memcpy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
21285 /* Do a structure assignment. */
21288 /* Restore original glyph pointers of TO. */
21289 memcpy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
21291 /* Copy the glyphs. */
21292 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
],
21293 min (from
->used
[TEXT_AREA
], to_used
) * sizeof (struct glyph
));
21295 /* If we filled only part of the TO row, fill the rest with
21296 space_glyph (which will display as empty space). */
21297 if (to_used
> from
->used
[TEXT_AREA
])
21298 fill_up_frame_row_with_spaces (to
, to_used
);
21301 /* Display one menu item on a TTY, by overwriting the glyphs in the
21302 frame F's desired glyph matrix with glyphs produced from the menu
21303 item text. Called from term.c to display TTY drop-down menus one
21306 ITEM_TEXT is the menu item text as a C string.
21308 FACE_ID is the face ID to be used for this menu item. FACE_ID
21309 could specify one of 3 faces: a face for an enabled item, a face
21310 for a disabled item, or a face for a selected item.
21312 X and Y are coordinates of the first glyph in the frame's desired
21313 matrix to be overwritten by the menu item. Since this is a TTY, Y
21314 is the zero-based number of the glyph row and X is the zero-based
21315 glyph number in the row, starting from left, where to start
21316 displaying the item.
21318 SUBMENU non-zero means this menu item drops down a submenu, which
21319 should be indicated by displaying a proper visual cue after the
21323 display_tty_menu_item (const char *item_text
, int width
, int face_id
,
21324 int x
, int y
, int submenu
)
21327 struct frame
*f
= SELECTED_FRAME ();
21328 struct window
*w
= XWINDOW (f
->selected_window
);
21329 int saved_used
, saved_truncated
, saved_width
, saved_reversed
;
21330 struct glyph_row
*row
;
21331 size_t item_len
= strlen (item_text
);
21333 eassert (FRAME_TERMCAP_P (f
));
21335 /* Don't write beyond the matrix's last row. This can happen for
21336 TTY screens that are not high enough to show the entire menu.
21337 (This is actually a bit of defensive programming, as
21338 tty_menu_display already limits the number of menu items to one
21339 less than the number of screen lines.) */
21340 if (y
>= f
->desired_matrix
->nrows
)
21343 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
+ y
, MENU_FACE_ID
);
21344 it
.first_visible_x
= 0;
21345 it
.last_visible_x
= FRAME_COLS (f
) - 1;
21346 row
= it
.glyph_row
;
21347 /* Start with the row contents from the current matrix. */
21348 deep_copy_glyph_row (row
, f
->current_matrix
->rows
+ y
);
21349 saved_width
= row
->full_width_p
;
21350 row
->full_width_p
= 1;
21351 saved_reversed
= row
->reversed_p
;
21352 row
->reversed_p
= 0;
21353 row
->enabled_p
= true;
21355 /* Arrange for the menu item glyphs to start at (X,Y) and have the
21357 eassert (x
< f
->desired_matrix
->matrix_w
);
21358 it
.current_x
= it
.hpos
= x
;
21359 it
.current_y
= it
.vpos
= y
;
21360 saved_used
= row
->used
[TEXT_AREA
];
21361 saved_truncated
= row
->truncated_on_right_p
;
21362 row
->used
[TEXT_AREA
] = x
;
21363 it
.face_id
= face_id
;
21364 it
.line_wrap
= TRUNCATE
;
21366 /* FIXME: This should be controlled by a user option. See the
21367 comments in redisplay_tool_bar and display_mode_line about this.
21368 Also, if paragraph_embedding could ever be R2L, changes will be
21369 needed to avoid shifting to the right the row characters in
21370 term.c:append_glyph. */
21371 it
.paragraph_embedding
= L2R
;
21373 /* Pad with a space on the left. */
21374 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 1, 0, FRAME_COLS (f
) - 1, -1);
21376 /* Display the menu item, pad with spaces to WIDTH. */
21379 display_string (item_text
, Qnil
, Qnil
, 0, 0, &it
,
21380 item_len
, 0, FRAME_COLS (f
) - 1, -1);
21382 /* Indicate with " >" that there's a submenu. */
21383 display_string (" >", Qnil
, Qnil
, 0, 0, &it
, width
, 0,
21384 FRAME_COLS (f
) - 1, -1);
21387 display_string (item_text
, Qnil
, Qnil
, 0, 0, &it
,
21388 width
, 0, FRAME_COLS (f
) - 1, -1);
21390 row
->used
[TEXT_AREA
] = max (saved_used
, row
->used
[TEXT_AREA
]);
21391 row
->truncated_on_right_p
= saved_truncated
;
21392 row
->hash
= row_hash (row
);
21393 row
->full_width_p
= saved_width
;
21394 row
->reversed_p
= saved_reversed
;
21397 /***********************************************************************
21399 ***********************************************************************/
21401 /* Redisplay mode lines in the window tree whose root is WINDOW. If
21402 FORCE is non-zero, redisplay mode lines unconditionally.
21403 Otherwise, redisplay only mode lines that are garbaged. Value is
21404 the number of windows whose mode lines were redisplayed. */
21407 redisplay_mode_lines (Lisp_Object window
, bool force
)
21411 while (!NILP (window
))
21413 struct window
*w
= XWINDOW (window
);
21415 if (WINDOWP (w
->contents
))
21416 nwindows
+= redisplay_mode_lines (w
->contents
, force
);
21418 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
21419 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
21421 struct text_pos lpoint
;
21422 struct buffer
*old
= current_buffer
;
21424 /* Set the window's buffer for the mode line display. */
21425 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
21426 set_buffer_internal_1 (XBUFFER (w
->contents
));
21428 /* Point refers normally to the selected window. For any
21429 other window, set up appropriate value. */
21430 if (!EQ (window
, selected_window
))
21432 struct text_pos pt
;
21434 CLIP_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
21435 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
21438 /* Display mode lines. */
21439 clear_glyph_matrix (w
->desired_matrix
);
21440 if (display_mode_lines (w
))
21443 /* Restore old settings. */
21444 set_buffer_internal_1 (old
);
21445 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
21455 /* Display the mode and/or header line of window W. Value is the
21456 sum number of mode lines and header lines displayed. */
21459 display_mode_lines (struct window
*w
)
21461 Lisp_Object old_selected_window
= selected_window
;
21462 Lisp_Object old_selected_frame
= selected_frame
;
21463 Lisp_Object new_frame
= w
->frame
;
21464 Lisp_Object old_frame_selected_window
= XFRAME (new_frame
)->selected_window
;
21467 selected_frame
= new_frame
;
21468 /* FIXME: If we were to allow the mode-line's computation changing the buffer
21469 or window's point, then we'd need select_window_1 here as well. */
21470 XSETWINDOW (selected_window
, w
);
21471 XFRAME (new_frame
)->selected_window
= selected_window
;
21473 /* These will be set while the mode line specs are processed. */
21474 line_number_displayed
= 0;
21475 w
->column_number_displayed
= -1;
21477 if (WINDOW_WANTS_MODELINE_P (w
))
21479 struct window
*sel_w
= XWINDOW (old_selected_window
);
21481 /* Select mode line face based on the real selected window. */
21482 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
21483 BVAR (current_buffer
, mode_line_format
));
21487 if (WINDOW_WANTS_HEADER_LINE_P (w
))
21489 display_mode_line (w
, HEADER_LINE_FACE_ID
,
21490 BVAR (current_buffer
, header_line_format
));
21494 XFRAME (new_frame
)->selected_window
= old_frame_selected_window
;
21495 selected_frame
= old_selected_frame
;
21496 selected_window
= old_selected_window
;
21498 w
->must_be_updated_p
= true;
21503 /* Display mode or header line of window W. FACE_ID specifies which
21504 line to display; it is either MODE_LINE_FACE_ID or
21505 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
21506 display. Value is the pixel height of the mode/header line
21510 display_mode_line (struct window
*w
, enum face_id face_id
, Lisp_Object format
)
21514 ptrdiff_t count
= SPECPDL_INDEX ();
21516 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
21517 /* Don't extend on a previously drawn mode-line.
21518 This may happen if called from pos_visible_p. */
21519 it
.glyph_row
->enabled_p
= false;
21520 prepare_desired_row (it
.glyph_row
);
21522 it
.glyph_row
->mode_line_p
= 1;
21524 /* FIXME: This should be controlled by a user option. But
21525 supporting such an option is not trivial, since the mode line is
21526 made up of many separate strings. */
21527 it
.paragraph_embedding
= L2R
;
21529 record_unwind_protect (unwind_format_mode_line
,
21530 format_mode_line_unwind_data (NULL
, NULL
, Qnil
, 0));
21532 mode_line_target
= MODE_LINE_DISPLAY
;
21534 /* Temporarily make frame's keyboard the current kboard so that
21535 kboard-local variables in the mode_line_format will get the right
21537 push_kboard (FRAME_KBOARD (it
.f
));
21538 record_unwind_save_match_data ();
21539 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
21542 unbind_to (count
, Qnil
);
21544 /* Fill up with spaces. */
21545 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
21547 compute_line_metrics (&it
);
21548 it
.glyph_row
->full_width_p
= 1;
21549 it
.glyph_row
->continued_p
= 0;
21550 it
.glyph_row
->truncated_on_left_p
= 0;
21551 it
.glyph_row
->truncated_on_right_p
= 0;
21553 /* Make a 3D mode-line have a shadow at its right end. */
21554 face
= FACE_FROM_ID (it
.f
, face_id
);
21555 extend_face_to_end_of_line (&it
);
21556 if (face
->box
!= FACE_NO_BOX
)
21558 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
21559 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
21560 last
->right_box_line_p
= 1;
21563 return it
.glyph_row
->height
;
21566 /* Move element ELT in LIST to the front of LIST.
21567 Return the updated list. */
21570 move_elt_to_front (Lisp_Object elt
, Lisp_Object list
)
21572 register Lisp_Object tail
, prev
;
21573 register Lisp_Object tem
;
21577 while (CONSP (tail
))
21583 /* Splice out the link TAIL. */
21585 list
= XCDR (tail
);
21587 Fsetcdr (prev
, XCDR (tail
));
21589 /* Now make it the first. */
21590 Fsetcdr (tail
, list
);
21595 tail
= XCDR (tail
);
21599 /* Not found--return unchanged LIST. */
21603 /* Contribute ELT to the mode line for window IT->w. How it
21604 translates into text depends on its data type.
21606 IT describes the display environment in which we display, as usual.
21608 DEPTH is the depth in recursion. It is used to prevent
21609 infinite recursion here.
21611 FIELD_WIDTH is the number of characters the display of ELT should
21612 occupy in the mode line, and PRECISION is the maximum number of
21613 characters to display from ELT's representation. See
21614 display_string for details.
21616 Returns the hpos of the end of the text generated by ELT.
21618 PROPS is a property list to add to any string we encounter.
21620 If RISKY is nonzero, remove (disregard) any properties in any string
21621 we encounter, and ignore :eval and :propertize.
21623 The global variable `mode_line_target' determines whether the
21624 output is passed to `store_mode_line_noprop',
21625 `store_mode_line_string', or `display_string'. */
21628 display_mode_element (struct it
*it
, int depth
, int field_width
, int precision
,
21629 Lisp_Object elt
, Lisp_Object props
, int risky
)
21631 int n
= 0, field
, prec
;
21636 elt
= build_string ("*too-deep*");
21640 switch (XTYPE (elt
))
21644 /* A string: output it and check for %-constructs within it. */
21646 ptrdiff_t offset
= 0;
21648 if (SCHARS (elt
) > 0
21649 && (!NILP (props
) || risky
))
21651 Lisp_Object oprops
, aelt
;
21652 oprops
= Ftext_properties_at (make_number (0), elt
);
21654 /* If the starting string's properties are not what
21655 we want, translate the string. Also, if the string
21656 is risky, do that anyway. */
21658 if (NILP (Fequal (props
, oprops
)) || risky
)
21660 /* If the starting string has properties,
21661 merge the specified ones onto the existing ones. */
21662 if (! NILP (oprops
) && !risky
)
21666 oprops
= Fcopy_sequence (oprops
);
21668 while (CONSP (tem
))
21670 oprops
= Fplist_put (oprops
, XCAR (tem
),
21671 XCAR (XCDR (tem
)));
21672 tem
= XCDR (XCDR (tem
));
21677 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
21678 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
21680 /* AELT is what we want. Move it to the front
21681 without consing. */
21683 mode_line_proptrans_alist
21684 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
21690 /* If AELT has the wrong props, it is useless.
21691 so get rid of it. */
21693 mode_line_proptrans_alist
21694 = Fdelq (aelt
, mode_line_proptrans_alist
);
21696 elt
= Fcopy_sequence (elt
);
21697 Fset_text_properties (make_number (0), Flength (elt
),
21699 /* Add this item to mode_line_proptrans_alist. */
21700 mode_line_proptrans_alist
21701 = Fcons (Fcons (elt
, props
),
21702 mode_line_proptrans_alist
);
21703 /* Truncate mode_line_proptrans_alist
21704 to at most 50 elements. */
21705 tem
= Fnthcdr (make_number (50),
21706 mode_line_proptrans_alist
);
21708 XSETCDR (tem
, Qnil
);
21717 prec
= precision
- n
;
21718 switch (mode_line_target
)
21720 case MODE_LINE_NOPROP
:
21721 case MODE_LINE_TITLE
:
21722 n
+= store_mode_line_noprop (SSDATA (elt
), -1, prec
);
21724 case MODE_LINE_STRING
:
21725 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
21727 case MODE_LINE_DISPLAY
:
21728 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
21729 0, prec
, 0, STRING_MULTIBYTE (elt
));
21736 /* Handle the non-literal case. */
21738 while ((precision
<= 0 || n
< precision
)
21739 && SREF (elt
, offset
) != 0
21740 && (mode_line_target
!= MODE_LINE_DISPLAY
21741 || it
->current_x
< it
->last_visible_x
))
21743 ptrdiff_t last_offset
= offset
;
21745 /* Advance to end of string or next format specifier. */
21746 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
21749 if (offset
- 1 != last_offset
)
21751 ptrdiff_t nchars
, nbytes
;
21753 /* Output to end of string or up to '%'. Field width
21754 is length of string. Don't output more than
21755 PRECISION allows us. */
21758 prec
= c_string_width (SDATA (elt
) + last_offset
,
21759 offset
- last_offset
, precision
- n
,
21762 switch (mode_line_target
)
21764 case MODE_LINE_NOPROP
:
21765 case MODE_LINE_TITLE
:
21766 n
+= store_mode_line_noprop (SSDATA (elt
) + last_offset
, 0, prec
);
21768 case MODE_LINE_STRING
:
21770 ptrdiff_t bytepos
= last_offset
;
21771 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
21772 ptrdiff_t endpos
= (precision
<= 0
21773 ? string_byte_to_char (elt
, offset
)
21774 : charpos
+ nchars
);
21776 n
+= store_mode_line_string (NULL
,
21777 Fsubstring (elt
, make_number (charpos
),
21778 make_number (endpos
)),
21782 case MODE_LINE_DISPLAY
:
21784 ptrdiff_t bytepos
= last_offset
;
21785 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
21787 if (precision
<= 0)
21788 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
21789 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
21791 STRING_MULTIBYTE (elt
));
21796 else /* c == '%' */
21798 ptrdiff_t percent_position
= offset
;
21800 /* Get the specified minimum width. Zero means
21803 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
21804 field
= field
* 10 + c
- '0';
21806 /* Don't pad beyond the total padding allowed. */
21807 if (field_width
- n
> 0 && field
> field_width
- n
)
21808 field
= field_width
- n
;
21810 /* Note that either PRECISION <= 0 or N < PRECISION. */
21811 prec
= precision
- n
;
21814 n
+= display_mode_element (it
, depth
, field
, prec
,
21815 Vglobal_mode_string
, props
,
21820 ptrdiff_t bytepos
, charpos
;
21822 Lisp_Object string
;
21824 bytepos
= percent_position
;
21825 charpos
= (STRING_MULTIBYTE (elt
)
21826 ? string_byte_to_char (elt
, bytepos
)
21828 spec
= decode_mode_spec (it
->w
, c
, field
, &string
);
21829 multibyte
= STRINGP (string
) && STRING_MULTIBYTE (string
);
21831 switch (mode_line_target
)
21833 case MODE_LINE_NOPROP
:
21834 case MODE_LINE_TITLE
:
21835 n
+= store_mode_line_noprop (spec
, field
, prec
);
21837 case MODE_LINE_STRING
:
21839 Lisp_Object tem
= build_string (spec
);
21840 props
= Ftext_properties_at (make_number (charpos
), elt
);
21841 /* Should only keep face property in props */
21842 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
21845 case MODE_LINE_DISPLAY
:
21847 int nglyphs_before
, nwritten
;
21849 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
21850 nwritten
= display_string (spec
, string
, elt
,
21855 /* Assign to the glyphs written above the
21856 string where the `%x' came from, position
21860 struct glyph
*glyph
21861 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
21865 for (i
= 0; i
< nwritten
; ++i
)
21867 glyph
[i
].object
= elt
;
21868 glyph
[i
].charpos
= charpos
;
21885 /* A symbol: process the value of the symbol recursively
21886 as if it appeared here directly. Avoid error if symbol void.
21887 Special case: if value of symbol is a string, output the string
21890 register Lisp_Object tem
;
21892 /* If the variable is not marked as risky to set
21893 then its contents are risky to use. */
21894 if (NILP (Fget (elt
, Qrisky_local_variable
)))
21897 tem
= Fboundp (elt
);
21900 tem
= Fsymbol_value (elt
);
21901 /* If value is a string, output that string literally:
21902 don't check for % within it. */
21906 if (!EQ (tem
, elt
))
21908 /* Give up right away for nil or t. */
21918 register Lisp_Object car
, tem
;
21920 /* A cons cell: five distinct cases.
21921 If first element is :eval or :propertize, do something special.
21922 If first element is a string or a cons, process all the elements
21923 and effectively concatenate them.
21924 If first element is a negative number, truncate displaying cdr to
21925 at most that many characters. If positive, pad (with spaces)
21926 to at least that many characters.
21927 If first element is a symbol, process the cadr or caddr recursively
21928 according to whether the symbol's value is non-nil or nil. */
21930 if (EQ (car
, QCeval
))
21932 /* An element of the form (:eval FORM) means evaluate FORM
21933 and use the result as mode line elements. */
21938 if (CONSP (XCDR (elt
)))
21941 spec
= safe__eval (true, XCAR (XCDR (elt
)));
21942 n
+= display_mode_element (it
, depth
, field_width
- n
,
21943 precision
- n
, spec
, props
,
21947 else if (EQ (car
, QCpropertize
))
21949 /* An element of the form (:propertize ELT PROPS...)
21950 means display ELT but applying properties PROPS. */
21955 if (CONSP (XCDR (elt
)))
21956 n
+= display_mode_element (it
, depth
, field_width
- n
,
21957 precision
- n
, XCAR (XCDR (elt
)),
21958 XCDR (XCDR (elt
)), risky
);
21960 else if (SYMBOLP (car
))
21962 tem
= Fboundp (car
);
21966 /* elt is now the cdr, and we know it is a cons cell.
21967 Use its car if CAR has a non-nil value. */
21970 tem
= Fsymbol_value (car
);
21977 /* Symbol's value is nil (or symbol is unbound)
21978 Get the cddr of the original list
21979 and if possible find the caddr and use that. */
21983 else if (!CONSP (elt
))
21988 else if (INTEGERP (car
))
21990 register int lim
= XINT (car
);
21994 /* Negative int means reduce maximum width. */
21995 if (precision
<= 0)
21998 precision
= min (precision
, -lim
);
22002 /* Padding specified. Don't let it be more than
22003 current maximum. */
22005 lim
= min (precision
, lim
);
22007 /* If that's more padding than already wanted, queue it.
22008 But don't reduce padding already specified even if
22009 that is beyond the current truncation point. */
22010 field_width
= max (lim
, field_width
);
22014 else if (STRINGP (car
) || CONSP (car
))
22016 Lisp_Object halftail
= elt
;
22020 && (precision
<= 0 || n
< precision
))
22022 n
+= display_mode_element (it
, depth
,
22023 /* Do padding only after the last
22024 element in the list. */
22025 (! CONSP (XCDR (elt
))
22028 precision
- n
, XCAR (elt
),
22032 if ((len
& 1) == 0)
22033 halftail
= XCDR (halftail
);
22034 /* Check for cycle. */
22035 if (EQ (halftail
, elt
))
22044 elt
= build_string ("*invalid*");
22048 /* Pad to FIELD_WIDTH. */
22049 if (field_width
> 0 && n
< field_width
)
22051 switch (mode_line_target
)
22053 case MODE_LINE_NOPROP
:
22054 case MODE_LINE_TITLE
:
22055 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
22057 case MODE_LINE_STRING
:
22058 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
22060 case MODE_LINE_DISPLAY
:
22061 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
22070 /* Store a mode-line string element in mode_line_string_list.
22072 If STRING is non-null, display that C string. Otherwise, the Lisp
22073 string LISP_STRING is displayed.
22075 FIELD_WIDTH is the minimum number of output glyphs to produce.
22076 If STRING has fewer characters than FIELD_WIDTH, pad to the right
22077 with spaces. FIELD_WIDTH <= 0 means don't pad.
22079 PRECISION is the maximum number of characters to output from
22080 STRING. PRECISION <= 0 means don't truncate the string.
22082 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
22083 properties to the string.
22085 PROPS are the properties to add to the string.
22086 The mode_line_string_face face property is always added to the string.
22090 store_mode_line_string (const char *string
, Lisp_Object lisp_string
, int copy_string
,
22091 int field_width
, int precision
, Lisp_Object props
)
22096 if (string
!= NULL
)
22098 len
= strlen (string
);
22099 if (precision
> 0 && len
> precision
)
22101 lisp_string
= make_string (string
, len
);
22103 props
= mode_line_string_face_prop
;
22104 else if (!NILP (mode_line_string_face
))
22106 Lisp_Object face
= Fplist_get (props
, Qface
);
22107 props
= Fcopy_sequence (props
);
22109 face
= mode_line_string_face
;
22111 face
= list2 (face
, mode_line_string_face
);
22112 props
= Fplist_put (props
, Qface
, face
);
22114 Fadd_text_properties (make_number (0), make_number (len
),
22115 props
, lisp_string
);
22119 len
= XFASTINT (Flength (lisp_string
));
22120 if (precision
> 0 && len
> precision
)
22123 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
22126 if (!NILP (mode_line_string_face
))
22130 props
= Ftext_properties_at (make_number (0), lisp_string
);
22131 face
= Fplist_get (props
, Qface
);
22133 face
= mode_line_string_face
;
22135 face
= list2 (face
, mode_line_string_face
);
22136 props
= list2 (Qface
, face
);
22138 lisp_string
= Fcopy_sequence (lisp_string
);
22141 Fadd_text_properties (make_number (0), make_number (len
),
22142 props
, lisp_string
);
22147 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
22151 if (field_width
> len
)
22153 field_width
-= len
;
22154 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
22156 Fadd_text_properties (make_number (0), make_number (field_width
),
22157 props
, lisp_string
);
22158 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
22166 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
22168 doc
: /* Format a string out of a mode line format specification.
22169 First arg FORMAT specifies the mode line format (see `mode-line-format'
22170 for details) to use.
22172 By default, the format is evaluated for the currently selected window.
22174 Optional second arg FACE specifies the face property to put on all
22175 characters for which no face is specified. The value nil means the
22176 default face. The value t means whatever face the window's mode line
22177 currently uses (either `mode-line' or `mode-line-inactive',
22178 depending on whether the window is the selected window or not).
22179 An integer value means the value string has no text
22182 Optional third and fourth args WINDOW and BUFFER specify the window
22183 and buffer to use as the context for the formatting (defaults
22184 are the selected window and the WINDOW's buffer). */)
22185 (Lisp_Object format
, Lisp_Object face
,
22186 Lisp_Object window
, Lisp_Object buffer
)
22191 struct buffer
*old_buffer
= NULL
;
22193 int no_props
= INTEGERP (face
);
22194 ptrdiff_t count
= SPECPDL_INDEX ();
22196 int string_start
= 0;
22198 w
= decode_any_window (window
);
22199 XSETWINDOW (window
, w
);
22202 buffer
= w
->contents
;
22203 CHECK_BUFFER (buffer
);
22205 /* Make formatting the modeline a non-op when noninteractive, otherwise
22206 there will be problems later caused by a partially initialized frame. */
22207 if (NILP (format
) || noninteractive
)
22208 return empty_unibyte_string
;
22213 face_id
= (NILP (face
) || EQ (face
, Qdefault
)) ? DEFAULT_FACE_ID
22214 : EQ (face
, Qt
) ? (EQ (window
, selected_window
)
22215 ? MODE_LINE_FACE_ID
: MODE_LINE_INACTIVE_FACE_ID
)
22216 : EQ (face
, Qmode_line
) ? MODE_LINE_FACE_ID
22217 : EQ (face
, Qmode_line_inactive
) ? MODE_LINE_INACTIVE_FACE_ID
22218 : EQ (face
, Qheader_line
) ? HEADER_LINE_FACE_ID
22219 : EQ (face
, Qtool_bar
) ? TOOL_BAR_FACE_ID
22222 old_buffer
= current_buffer
;
22224 /* Save things including mode_line_proptrans_alist,
22225 and set that to nil so that we don't alter the outer value. */
22226 record_unwind_protect (unwind_format_mode_line
,
22227 format_mode_line_unwind_data
22228 (XFRAME (WINDOW_FRAME (w
)),
22229 old_buffer
, selected_window
, 1));
22230 mode_line_proptrans_alist
= Qnil
;
22232 Fselect_window (window
, Qt
);
22233 set_buffer_internal_1 (XBUFFER (buffer
));
22235 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
22239 mode_line_target
= MODE_LINE_NOPROP
;
22240 mode_line_string_face_prop
= Qnil
;
22241 mode_line_string_list
= Qnil
;
22242 string_start
= MODE_LINE_NOPROP_LEN (0);
22246 mode_line_target
= MODE_LINE_STRING
;
22247 mode_line_string_list
= Qnil
;
22248 mode_line_string_face
= face
;
22249 mode_line_string_face_prop
22250 = NILP (face
) ? Qnil
: list2 (Qface
, face
);
22253 push_kboard (FRAME_KBOARD (it
.f
));
22254 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
22259 len
= MODE_LINE_NOPROP_LEN (string_start
);
22260 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
22264 mode_line_string_list
= Fnreverse (mode_line_string_list
);
22265 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
22266 empty_unibyte_string
);
22269 unbind_to (count
, Qnil
);
22273 /* Write a null-terminated, right justified decimal representation of
22274 the positive integer D to BUF using a minimal field width WIDTH. */
22277 pint2str (register char *buf
, register int width
, register ptrdiff_t d
)
22279 register char *p
= buf
;
22287 *p
++ = d
% 10 + '0';
22292 for (width
-= (int) (p
- buf
); width
> 0; --width
)
22303 /* Write a null-terminated, right justified decimal and "human
22304 readable" representation of the nonnegative integer D to BUF using
22305 a minimal field width WIDTH. D should be smaller than 999.5e24. */
22307 static const char power_letter
[] =
22321 pint2hrstr (char *buf
, int width
, ptrdiff_t d
)
22323 /* We aim to represent the nonnegative integer D as
22324 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
22325 ptrdiff_t quotient
= d
;
22327 /* -1 means: do not use TENTHS. */
22331 /* Length of QUOTIENT.TENTHS as a string. */
22337 if (quotient
>= 1000)
22339 /* Scale to the appropriate EXPONENT. */
22342 remainder
= quotient
% 1000;
22346 while (quotient
>= 1000);
22348 /* Round to nearest and decide whether to use TENTHS or not. */
22351 tenths
= remainder
/ 100;
22352 if (remainder
% 100 >= 50)
22359 if (quotient
== 10)
22367 if (remainder
>= 500)
22369 if (quotient
< 999)
22380 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
22381 if (tenths
== -1 && quotient
<= 99)
22388 p
= psuffix
= buf
+ max (width
, length
);
22390 /* Print EXPONENT. */
22391 *psuffix
++ = power_letter
[exponent
];
22394 /* Print TENTHS. */
22397 *--p
= '0' + tenths
;
22401 /* Print QUOTIENT. */
22404 int digit
= quotient
% 10;
22405 *--p
= '0' + digit
;
22407 while ((quotient
/= 10) != 0);
22409 /* Print leading spaces. */
22414 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
22415 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
22416 type of CODING_SYSTEM. Return updated pointer into BUF. */
22418 static unsigned char invalid_eol_type
[] = "(*invalid*)";
22421 decode_mode_spec_coding (Lisp_Object coding_system
, register char *buf
, int eol_flag
)
22424 bool multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
22425 const unsigned char *eol_str
;
22427 /* The EOL conversion we are using. */
22428 Lisp_Object eoltype
;
22430 val
= CODING_SYSTEM_SPEC (coding_system
);
22433 if (!VECTORP (val
)) /* Not yet decided. */
22435 *buf
++ = multibyte
? '-' : ' ';
22437 eoltype
= eol_mnemonic_undecided
;
22438 /* Don't mention EOL conversion if it isn't decided. */
22443 Lisp_Object eolvalue
;
22445 attrs
= AREF (val
, 0);
22446 eolvalue
= AREF (val
, 2);
22449 ? XFASTINT (CODING_ATTR_MNEMONIC (attrs
))
22454 /* The EOL conversion that is normal on this system. */
22456 if (NILP (eolvalue
)) /* Not yet decided. */
22457 eoltype
= eol_mnemonic_undecided
;
22458 else if (VECTORP (eolvalue
)) /* Not yet decided. */
22459 eoltype
= eol_mnemonic_undecided
;
22460 else /* eolvalue is Qunix, Qdos, or Qmac. */
22461 eoltype
= (EQ (eolvalue
, Qunix
)
22462 ? eol_mnemonic_unix
22463 : (EQ (eolvalue
, Qdos
) == 1
22464 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
22470 /* Mention the EOL conversion if it is not the usual one. */
22471 if (STRINGP (eoltype
))
22473 eol_str
= SDATA (eoltype
);
22474 eol_str_len
= SBYTES (eoltype
);
22476 else if (CHARACTERP (eoltype
))
22478 unsigned char *tmp
= alloca (MAX_MULTIBYTE_LENGTH
);
22479 int c
= XFASTINT (eoltype
);
22480 eol_str_len
= CHAR_STRING (c
, tmp
);
22485 eol_str
= invalid_eol_type
;
22486 eol_str_len
= sizeof (invalid_eol_type
) - 1;
22488 memcpy (buf
, eol_str
, eol_str_len
);
22489 buf
+= eol_str_len
;
22495 /* Return a string for the output of a mode line %-spec for window W,
22496 generated by character C. FIELD_WIDTH > 0 means pad the string
22497 returned with spaces to that value. Return a Lisp string in
22498 *STRING if the resulting string is taken from that Lisp string.
22500 Note we operate on the current buffer for most purposes. */
22502 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
22504 static const char *
22505 decode_mode_spec (struct window
*w
, register int c
, int field_width
,
22506 Lisp_Object
*string
)
22509 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
22510 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
22511 /* We are going to use f->decode_mode_spec_buffer as the buffer to
22512 produce strings from numerical values, so limit preposterously
22513 large values of FIELD_WIDTH to avoid overrunning the buffer's
22514 end. The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
22515 bytes plus the terminating null. */
22516 int width
= min (field_width
, FRAME_MESSAGE_BUF_SIZE (f
));
22517 struct buffer
*b
= current_buffer
;
22525 if (!NILP (BVAR (b
, read_only
)))
22527 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
22532 /* This differs from %* only for a modified read-only buffer. */
22533 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
22535 if (!NILP (BVAR (b
, read_only
)))
22540 /* This differs from %* in ignoring read-only-ness. */
22541 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
22553 if (command_loop_level
> 5)
22555 p
= decode_mode_spec_buf
;
22556 for (i
= 0; i
< command_loop_level
; i
++)
22559 return decode_mode_spec_buf
;
22567 if (command_loop_level
> 5)
22569 p
= decode_mode_spec_buf
;
22570 for (i
= 0; i
< command_loop_level
; i
++)
22573 return decode_mode_spec_buf
;
22580 /* Let lots_of_dashes be a string of infinite length. */
22581 if (mode_line_target
== MODE_LINE_NOPROP
22582 || mode_line_target
== MODE_LINE_STRING
)
22584 if (field_width
<= 0
22585 || field_width
> sizeof (lots_of_dashes
))
22587 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
22588 decode_mode_spec_buf
[i
] = '-';
22589 decode_mode_spec_buf
[i
] = '\0';
22590 return decode_mode_spec_buf
;
22593 return lots_of_dashes
;
22597 obj
= BVAR (b
, name
);
22601 /* %c and %l are ignored in `frame-title-format'.
22602 (In redisplay_internal, the frame title is drawn _before_ the
22603 windows are updated, so the stuff which depends on actual
22604 window contents (such as %l) may fail to render properly, or
22605 even crash emacs.) */
22606 if (mode_line_target
== MODE_LINE_TITLE
)
22610 ptrdiff_t col
= current_column ();
22611 w
->column_number_displayed
= col
;
22612 pint2str (decode_mode_spec_buf
, width
, col
);
22613 return decode_mode_spec_buf
;
22617 #ifndef SYSTEM_MALLOC
22619 if (NILP (Vmemory_full
))
22622 return "!MEM FULL! ";
22629 /* %F displays the frame name. */
22630 if (!NILP (f
->title
))
22631 return SSDATA (f
->title
);
22632 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
22633 return SSDATA (f
->name
);
22637 obj
= BVAR (b
, filename
);
22642 ptrdiff_t size
= ZV
- BEGV
;
22643 pint2str (decode_mode_spec_buf
, width
, size
);
22644 return decode_mode_spec_buf
;
22649 ptrdiff_t size
= ZV
- BEGV
;
22650 pint2hrstr (decode_mode_spec_buf
, width
, size
);
22651 return decode_mode_spec_buf
;
22656 ptrdiff_t startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
22657 ptrdiff_t topline
, nlines
, height
;
22660 /* %c and %l are ignored in `frame-title-format'. */
22661 if (mode_line_target
== MODE_LINE_TITLE
)
22664 startpos
= marker_position (w
->start
);
22665 startpos_byte
= marker_byte_position (w
->start
);
22666 height
= WINDOW_TOTAL_LINES (w
);
22668 /* If we decided that this buffer isn't suitable for line numbers,
22669 don't forget that too fast. */
22670 if (w
->base_line_pos
== -1)
22673 /* If the buffer is very big, don't waste time. */
22674 if (INTEGERP (Vline_number_display_limit
)
22675 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
22677 w
->base_line_pos
= 0;
22678 w
->base_line_number
= 0;
22682 if (w
->base_line_number
> 0
22683 && w
->base_line_pos
> 0
22684 && w
->base_line_pos
<= startpos
)
22686 line
= w
->base_line_number
;
22687 linepos
= w
->base_line_pos
;
22688 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
22693 linepos
= BUF_BEGV (b
);
22694 linepos_byte
= BUF_BEGV_BYTE (b
);
22697 /* Count lines from base line to window start position. */
22698 nlines
= display_count_lines (linepos_byte
,
22702 topline
= nlines
+ line
;
22704 /* Determine a new base line, if the old one is too close
22705 or too far away, or if we did not have one.
22706 "Too close" means it's plausible a scroll-down would
22707 go back past it. */
22708 if (startpos
== BUF_BEGV (b
))
22710 w
->base_line_number
= topline
;
22711 w
->base_line_pos
= BUF_BEGV (b
);
22713 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
22714 || linepos
== BUF_BEGV (b
))
22716 ptrdiff_t limit
= BUF_BEGV (b
);
22717 ptrdiff_t limit_byte
= BUF_BEGV_BYTE (b
);
22718 ptrdiff_t position
;
22719 ptrdiff_t distance
=
22720 (height
* 2 + 30) * line_number_display_limit_width
;
22722 if (startpos
- distance
> limit
)
22724 limit
= startpos
- distance
;
22725 limit_byte
= CHAR_TO_BYTE (limit
);
22728 nlines
= display_count_lines (startpos_byte
,
22730 - (height
* 2 + 30),
22732 /* If we couldn't find the lines we wanted within
22733 line_number_display_limit_width chars per line,
22734 give up on line numbers for this window. */
22735 if (position
== limit_byte
&& limit
== startpos
- distance
)
22737 w
->base_line_pos
= -1;
22738 w
->base_line_number
= 0;
22742 w
->base_line_number
= topline
- nlines
;
22743 w
->base_line_pos
= BYTE_TO_CHAR (position
);
22746 /* Now count lines from the start pos to point. */
22747 nlines
= display_count_lines (startpos_byte
,
22748 PT_BYTE
, PT
, &junk
);
22750 /* Record that we did display the line number. */
22751 line_number_displayed
= 1;
22753 /* Make the string to show. */
22754 pint2str (decode_mode_spec_buf
, width
, topline
+ nlines
);
22755 return decode_mode_spec_buf
;
22758 char *p
= decode_mode_spec_buf
;
22759 int pad
= width
- 2;
22765 return decode_mode_spec_buf
;
22771 obj
= BVAR (b
, mode_name
);
22775 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
22781 ptrdiff_t pos
= marker_position (w
->start
);
22782 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
22784 if (w
->window_end_pos
<= BUF_Z (b
) - BUF_ZV (b
))
22786 if (pos
<= BUF_BEGV (b
))
22791 else if (pos
<= BUF_BEGV (b
))
22795 if (total
> 1000000)
22796 /* Do it differently for a large value, to avoid overflow. */
22797 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
22799 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
22800 /* We can't normally display a 3-digit number,
22801 so get us a 2-digit number that is close. */
22804 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
22805 return decode_mode_spec_buf
;
22809 /* Display percentage of size above the bottom of the screen. */
22812 ptrdiff_t toppos
= marker_position (w
->start
);
22813 ptrdiff_t botpos
= BUF_Z (b
) - w
->window_end_pos
;
22814 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
22816 if (botpos
>= BUF_ZV (b
))
22818 if (toppos
<= BUF_BEGV (b
))
22825 if (total
> 1000000)
22826 /* Do it differently for a large value, to avoid overflow. */
22827 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
22829 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
22830 /* We can't normally display a 3-digit number,
22831 so get us a 2-digit number that is close. */
22834 if (toppos
<= BUF_BEGV (b
))
22835 sprintf (decode_mode_spec_buf
, "Top%2"pD
"d%%", total
);
22837 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
22838 return decode_mode_spec_buf
;
22843 /* status of process */
22844 obj
= Fget_buffer_process (Fcurrent_buffer ());
22846 return "no process";
22848 obj
= Fsymbol_name (Fprocess_status (obj
));
22854 ptrdiff_t count
= inhibit_garbage_collection ();
22855 Lisp_Object val
= call1 (intern ("file-remote-p"),
22856 BVAR (current_buffer
, directory
));
22857 unbind_to (count
, Qnil
);
22866 /* coding-system (not including end-of-line format) */
22868 /* coding-system (including end-of-line type) */
22870 int eol_flag
= (c
== 'Z');
22871 char *p
= decode_mode_spec_buf
;
22873 if (! FRAME_WINDOW_P (f
))
22875 /* No need to mention EOL here--the terminal never needs
22876 to do EOL conversion. */
22877 p
= decode_mode_spec_coding (CODING_ID_NAME
22878 (FRAME_KEYBOARD_CODING (f
)->id
),
22880 p
= decode_mode_spec_coding (CODING_ID_NAME
22881 (FRAME_TERMINAL_CODING (f
)->id
),
22884 p
= decode_mode_spec_coding (BVAR (b
, buffer_file_coding_system
),
22887 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
22888 #ifdef subprocesses
22889 obj
= Fget_buffer_process (Fcurrent_buffer ());
22890 if (PROCESSP (obj
))
22892 p
= decode_mode_spec_coding
22893 (XPROCESS (obj
)->decode_coding_system
, p
, eol_flag
);
22894 p
= decode_mode_spec_coding
22895 (XPROCESS (obj
)->encode_coding_system
, p
, eol_flag
);
22897 #endif /* subprocesses */
22900 return decode_mode_spec_buf
;
22907 return SSDATA (obj
);
22914 /* Count up to COUNT lines starting from START_BYTE. COUNT negative
22915 means count lines back from START_BYTE. But don't go beyond
22916 LIMIT_BYTE. Return the number of lines thus found (always
22919 Set *BYTE_POS_PTR to the byte position where we stopped. This is
22920 either the position COUNT lines after/before START_BYTE, if we
22921 found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
22925 display_count_lines (ptrdiff_t start_byte
,
22926 ptrdiff_t limit_byte
, ptrdiff_t count
,
22927 ptrdiff_t *byte_pos_ptr
)
22929 register unsigned char *cursor
;
22930 unsigned char *base
;
22932 register ptrdiff_t ceiling
;
22933 register unsigned char *ceiling_addr
;
22934 ptrdiff_t orig_count
= count
;
22936 /* If we are not in selective display mode,
22937 check only for newlines. */
22938 int selective_display
= (!NILP (BVAR (current_buffer
, selective_display
))
22939 && !INTEGERP (BVAR (current_buffer
, selective_display
)));
22943 while (start_byte
< limit_byte
)
22945 ceiling
= BUFFER_CEILING_OF (start_byte
);
22946 ceiling
= min (limit_byte
- 1, ceiling
);
22947 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
22948 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
22952 if (selective_display
)
22954 while (*cursor
!= '\n' && *cursor
!= 015
22955 && ++cursor
!= ceiling_addr
)
22957 if (cursor
== ceiling_addr
)
22962 cursor
= memchr (cursor
, '\n', ceiling_addr
- cursor
);
22971 start_byte
+= cursor
- base
;
22972 *byte_pos_ptr
= start_byte
;
22976 while (cursor
< ceiling_addr
);
22978 start_byte
+= ceiling_addr
- base
;
22983 while (start_byte
> limit_byte
)
22985 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
22986 ceiling
= max (limit_byte
, ceiling
);
22987 ceiling_addr
= BYTE_POS_ADDR (ceiling
);
22988 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
22991 if (selective_display
)
22993 while (--cursor
>= ceiling_addr
22994 && *cursor
!= '\n' && *cursor
!= 015)
22996 if (cursor
< ceiling_addr
)
23001 cursor
= memrchr (ceiling_addr
, '\n', cursor
- ceiling_addr
);
23008 start_byte
+= cursor
- base
+ 1;
23009 *byte_pos_ptr
= start_byte
;
23010 /* When scanning backwards, we should
23011 not count the newline posterior to which we stop. */
23012 return - orig_count
- 1;
23015 start_byte
+= ceiling_addr
- base
;
23019 *byte_pos_ptr
= limit_byte
;
23022 return - orig_count
+ count
;
23023 return orig_count
- count
;
23029 /***********************************************************************
23031 ***********************************************************************/
23033 /* Display a NUL-terminated string, starting with index START.
23035 If STRING is non-null, display that C string. Otherwise, the Lisp
23036 string LISP_STRING is displayed. There's a case that STRING is
23037 non-null and LISP_STRING is not nil. It means STRING is a string
23038 data of LISP_STRING. In that case, we display LISP_STRING while
23039 ignoring its text properties.
23041 If FACE_STRING is not nil, FACE_STRING_POS is a position in
23042 FACE_STRING. Display STRING or LISP_STRING with the face at
23043 FACE_STRING_POS in FACE_STRING:
23045 Display the string in the environment given by IT, but use the
23046 standard display table, temporarily.
23048 FIELD_WIDTH is the minimum number of output glyphs to produce.
23049 If STRING has fewer characters than FIELD_WIDTH, pad to the right
23050 with spaces. If STRING has more characters, more than FIELD_WIDTH
23051 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
23053 PRECISION is the maximum number of characters to output from
23054 STRING. PRECISION < 0 means don't truncate the string.
23056 This is roughly equivalent to printf format specifiers:
23058 FIELD_WIDTH PRECISION PRINTF
23059 ----------------------------------------
23065 MULTIBYTE zero means do not display multibyte chars, > 0 means do
23066 display them, and < 0 means obey the current buffer's value of
23067 enable_multibyte_characters.
23069 Value is the number of columns displayed. */
23072 display_string (const char *string
, Lisp_Object lisp_string
, Lisp_Object face_string
,
23073 ptrdiff_t face_string_pos
, ptrdiff_t start
, struct it
*it
,
23074 int field_width
, int precision
, int max_x
, int multibyte
)
23076 int hpos_at_start
= it
->hpos
;
23077 int saved_face_id
= it
->face_id
;
23078 struct glyph_row
*row
= it
->glyph_row
;
23079 ptrdiff_t it_charpos
;
23081 /* Initialize the iterator IT for iteration over STRING beginning
23082 with index START. */
23083 reseat_to_string (it
, NILP (lisp_string
) ? string
: NULL
, lisp_string
, start
,
23084 precision
, field_width
, multibyte
);
23085 if (string
&& STRINGP (lisp_string
))
23086 /* LISP_STRING is the one returned by decode_mode_spec. We should
23087 ignore its text properties. */
23088 it
->stop_charpos
= it
->end_charpos
;
23090 /* If displaying STRING, set up the face of the iterator from
23091 FACE_STRING, if that's given. */
23092 if (STRINGP (face_string
))
23098 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
23099 0, &endptr
, it
->base_face_id
, 0);
23100 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23101 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
23104 /* Set max_x to the maximum allowed X position. Don't let it go
23105 beyond the right edge of the window. */
23107 max_x
= it
->last_visible_x
;
23109 max_x
= min (max_x
, it
->last_visible_x
);
23111 /* Skip over display elements that are not visible. because IT->w is
23113 if (it
->current_x
< it
->first_visible_x
)
23114 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
23115 MOVE_TO_POS
| MOVE_TO_X
);
23117 row
->ascent
= it
->max_ascent
;
23118 row
->height
= it
->max_ascent
+ it
->max_descent
;
23119 row
->phys_ascent
= it
->max_phys_ascent
;
23120 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
23121 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
23123 if (STRINGP (it
->string
))
23124 it_charpos
= IT_STRING_CHARPOS (*it
);
23126 it_charpos
= IT_CHARPOS (*it
);
23128 /* This condition is for the case that we are called with current_x
23129 past last_visible_x. */
23130 while (it
->current_x
< max_x
)
23132 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
23134 /* Get the next display element. */
23135 if (!get_next_display_element (it
))
23138 /* Produce glyphs. */
23139 x_before
= it
->current_x
;
23140 n_glyphs_before
= row
->used
[TEXT_AREA
];
23141 PRODUCE_GLYPHS (it
);
23143 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
23146 while (i
< nglyphs
)
23148 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
23150 if (it
->line_wrap
!= TRUNCATE
23151 && x
+ glyph
->pixel_width
> max_x
)
23153 /* End of continued line or max_x reached. */
23154 if (CHAR_GLYPH_PADDING_P (*glyph
))
23156 /* A wide character is unbreakable. */
23157 if (row
->reversed_p
)
23158 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
23159 - n_glyphs_before
);
23160 row
->used
[TEXT_AREA
] = n_glyphs_before
;
23161 it
->current_x
= x_before
;
23165 if (row
->reversed_p
)
23166 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
23167 - (n_glyphs_before
+ i
));
23168 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
23173 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
23175 /* Glyph is at least partially visible. */
23177 if (x
< it
->first_visible_x
)
23178 row
->x
= x
- it
->first_visible_x
;
23182 /* Glyph is off the left margin of the display area.
23183 Should not happen. */
23187 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
23188 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
23189 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
23190 row
->phys_height
= max (row
->phys_height
,
23191 it
->max_phys_ascent
+ it
->max_phys_descent
);
23192 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
23193 it
->max_extra_line_spacing
);
23194 x
+= glyph
->pixel_width
;
23198 /* Stop if max_x reached. */
23202 /* Stop at line ends. */
23203 if (ITERATOR_AT_END_OF_LINE_P (it
))
23205 it
->continuation_lines_width
= 0;
23209 set_iterator_to_next (it
, 1);
23210 if (STRINGP (it
->string
))
23211 it_charpos
= IT_STRING_CHARPOS (*it
);
23213 it_charpos
= IT_CHARPOS (*it
);
23215 /* Stop if truncating at the right edge. */
23216 if (it
->line_wrap
== TRUNCATE
23217 && it
->current_x
>= it
->last_visible_x
)
23219 /* Add truncation mark, but don't do it if the line is
23220 truncated at a padding space. */
23221 if (it_charpos
< it
->string_nchars
)
23223 if (!FRAME_WINDOW_P (it
->f
))
23227 if (it
->current_x
> it
->last_visible_x
)
23229 if (!row
->reversed_p
)
23231 for (ii
= row
->used
[TEXT_AREA
] - 1; ii
> 0; --ii
)
23232 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
23237 for (ii
= 0; ii
< row
->used
[TEXT_AREA
]; ii
++)
23238 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
23240 unproduce_glyphs (it
, ii
+ 1);
23241 ii
= row
->used
[TEXT_AREA
] - (ii
+ 1);
23243 for (n
= row
->used
[TEXT_AREA
]; ii
< n
; ++ii
)
23245 row
->used
[TEXT_AREA
] = ii
;
23246 produce_special_glyphs (it
, IT_TRUNCATION
);
23249 produce_special_glyphs (it
, IT_TRUNCATION
);
23251 row
->truncated_on_right_p
= 1;
23257 /* Maybe insert a truncation at the left. */
23258 if (it
->first_visible_x
23261 if (!FRAME_WINDOW_P (it
->f
)
23262 || (row
->reversed_p
23263 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
23264 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
23265 insert_left_trunc_glyphs (it
);
23266 row
->truncated_on_left_p
= 1;
23269 it
->face_id
= saved_face_id
;
23271 /* Value is number of columns displayed. */
23272 return it
->hpos
- hpos_at_start
;
23277 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
23278 appears as an element of LIST or as the car of an element of LIST.
23279 If PROPVAL is a list, compare each element against LIST in that
23280 way, and return 1/2 if any element of PROPVAL is found in LIST.
23281 Otherwise return 0. This function cannot quit.
23282 The return value is 2 if the text is invisible but with an ellipsis
23283 and 1 if it's invisible and without an ellipsis. */
23286 invisible_p (register Lisp_Object propval
, Lisp_Object list
)
23288 register Lisp_Object tail
, proptail
;
23290 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
23292 register Lisp_Object tem
;
23294 if (EQ (propval
, tem
))
23296 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
23297 return NILP (XCDR (tem
)) ? 1 : 2;
23300 if (CONSP (propval
))
23302 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
23304 Lisp_Object propelt
;
23305 propelt
= XCAR (proptail
);
23306 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
23308 register Lisp_Object tem
;
23310 if (EQ (propelt
, tem
))
23312 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
23313 return NILP (XCDR (tem
)) ? 1 : 2;
23321 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
23322 doc
: /* Non-nil if the property makes the text invisible.
23323 POS-OR-PROP can be a marker or number, in which case it is taken to be
23324 a position in the current buffer and the value of the `invisible' property
23325 is checked; or it can be some other value, which is then presumed to be the
23326 value of the `invisible' property of the text of interest.
23327 The non-nil value returned can be t for truly invisible text or something
23328 else if the text is replaced by an ellipsis. */)
23329 (Lisp_Object pos_or_prop
)
23332 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
23333 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
23335 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
23336 return (invis
== 0 ? Qnil
23338 : make_number (invis
));
23341 /* Calculate a width or height in pixels from a specification using
23342 the following elements:
23345 NUM - a (fractional) multiple of the default font width/height
23346 (NUM) - specifies exactly NUM pixels
23347 UNIT - a fixed number of pixels, see below.
23348 ELEMENT - size of a display element in pixels, see below.
23349 (NUM . SPEC) - equals NUM * SPEC
23350 (+ SPEC SPEC ...) - add pixel values
23351 (- SPEC SPEC ...) - subtract pixel values
23352 (- SPEC) - negate pixel value
23355 INT or FLOAT - a number constant
23356 SYMBOL - use symbol's (buffer local) variable binding.
23359 in - pixels per inch *)
23360 mm - pixels per 1/1000 meter *)
23361 cm - pixels per 1/100 meter *)
23362 width - width of current font in pixels.
23363 height - height of current font in pixels.
23365 *) using the ratio(s) defined in display-pixels-per-inch.
23369 left-fringe - left fringe width in pixels
23370 right-fringe - right fringe width in pixels
23372 left-margin - left margin width in pixels
23373 right-margin - right margin width in pixels
23375 scroll-bar - scroll-bar area width in pixels
23379 Pixels corresponding to 5 inches:
23382 Total width of non-text areas on left side of window (if scroll-bar is on left):
23383 '(space :width (+ left-fringe left-margin scroll-bar))
23385 Align to first text column (in header line):
23386 '(space :align-to 0)
23388 Align to middle of text area minus half the width of variable `my-image'
23389 containing a loaded image:
23390 '(space :align-to (0.5 . (- text my-image)))
23392 Width of left margin minus width of 1 character in the default font:
23393 '(space :width (- left-margin 1))
23395 Width of left margin minus width of 2 characters in the current font:
23396 '(space :width (- left-margin (2 . width)))
23398 Center 1 character over left-margin (in header line):
23399 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
23401 Different ways to express width of left fringe plus left margin minus one pixel:
23402 '(space :width (- (+ left-fringe left-margin) (1)))
23403 '(space :width (+ left-fringe left-margin (- (1))))
23404 '(space :width (+ left-fringe left-margin (-1)))
23409 calc_pixel_width_or_height (double *res
, struct it
*it
, Lisp_Object prop
,
23410 struct font
*font
, int width_p
, int *align_to
)
23414 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
23415 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
23418 return OK_PIXELS (0);
23420 eassert (FRAME_LIVE_P (it
->f
));
23422 if (SYMBOLP (prop
))
23424 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
23426 char *unit
= SSDATA (SYMBOL_NAME (prop
));
23428 if (unit
[0] == 'i' && unit
[1] == 'n')
23430 else if (unit
[0] == 'm' && unit
[1] == 'm')
23432 else if (unit
[0] == 'c' && unit
[1] == 'm')
23438 double ppi
= (width_p
? FRAME_RES_X (it
->f
)
23439 : FRAME_RES_Y (it
->f
));
23442 return OK_PIXELS (ppi
/ pixels
);
23447 #ifdef HAVE_WINDOW_SYSTEM
23448 if (EQ (prop
, Qheight
))
23449 return OK_PIXELS (font
? FONT_HEIGHT (font
) : FRAME_LINE_HEIGHT (it
->f
));
23450 if (EQ (prop
, Qwidth
))
23451 return OK_PIXELS (font
? FONT_WIDTH (font
) : FRAME_COLUMN_WIDTH (it
->f
));
23453 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
23454 return OK_PIXELS (1);
23457 if (EQ (prop
, Qtext
))
23458 return OK_PIXELS (width_p
23459 ? window_box_width (it
->w
, TEXT_AREA
)
23460 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
23462 if (align_to
&& *align_to
< 0)
23465 if (EQ (prop
, Qleft
))
23466 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
23467 if (EQ (prop
, Qright
))
23468 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
23469 if (EQ (prop
, Qcenter
))
23470 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
23471 + window_box_width (it
->w
, TEXT_AREA
) / 2);
23472 if (EQ (prop
, Qleft_fringe
))
23473 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
23474 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
23475 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
23476 if (EQ (prop
, Qright_fringe
))
23477 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
23478 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
23479 : window_box_right_offset (it
->w
, TEXT_AREA
));
23480 if (EQ (prop
, Qleft_margin
))
23481 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
23482 if (EQ (prop
, Qright_margin
))
23483 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
23484 if (EQ (prop
, Qscroll_bar
))
23485 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
23487 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
23488 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
23489 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
23494 if (EQ (prop
, Qleft_fringe
))
23495 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
23496 if (EQ (prop
, Qright_fringe
))
23497 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
23498 if (EQ (prop
, Qleft_margin
))
23499 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
23500 if (EQ (prop
, Qright_margin
))
23501 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
23502 if (EQ (prop
, Qscroll_bar
))
23503 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
23506 prop
= buffer_local_value (prop
, it
->w
->contents
);
23507 if (EQ (prop
, Qunbound
))
23511 if (INTEGERP (prop
) || FLOATP (prop
))
23513 int base_unit
= (width_p
23514 ? FRAME_COLUMN_WIDTH (it
->f
)
23515 : FRAME_LINE_HEIGHT (it
->f
));
23516 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
23521 Lisp_Object car
= XCAR (prop
);
23522 Lisp_Object cdr
= XCDR (prop
);
23526 #ifdef HAVE_WINDOW_SYSTEM
23527 if (FRAME_WINDOW_P (it
->f
)
23528 && valid_image_p (prop
))
23530 ptrdiff_t id
= lookup_image (it
->f
, prop
);
23531 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
23533 return OK_PIXELS (width_p
? img
->width
: img
->height
);
23536 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
23542 while (CONSP (cdr
))
23544 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
23545 font
, width_p
, align_to
))
23548 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
23553 if (EQ (car
, Qminus
))
23555 return OK_PIXELS (pixels
);
23558 car
= buffer_local_value (car
, it
->w
->contents
);
23559 if (EQ (car
, Qunbound
))
23563 if (INTEGERP (car
) || FLOATP (car
))
23566 pixels
= XFLOATINT (car
);
23568 return OK_PIXELS (pixels
);
23569 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
23570 font
, width_p
, align_to
))
23571 return OK_PIXELS (pixels
* fact
);
23582 /***********************************************************************
23584 ***********************************************************************/
23586 #ifdef HAVE_WINDOW_SYSTEM
23591 dump_glyph_string (struct glyph_string
*s
)
23593 fprintf (stderr
, "glyph string\n");
23594 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
23595 s
->x
, s
->y
, s
->width
, s
->height
);
23596 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
23597 fprintf (stderr
, " hl = %d\n", s
->hl
);
23598 fprintf (stderr
, " left overhang = %d, right = %d\n",
23599 s
->left_overhang
, s
->right_overhang
);
23600 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
23601 fprintf (stderr
, " extends to end of line = %d\n",
23602 s
->extends_to_end_of_line_p
);
23603 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
23604 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
23607 #endif /* GLYPH_DEBUG */
23609 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
23610 of XChar2b structures for S; it can't be allocated in
23611 init_glyph_string because it must be allocated via `alloca'. W
23612 is the window on which S is drawn. ROW and AREA are the glyph row
23613 and area within the row from which S is constructed. START is the
23614 index of the first glyph structure covered by S. HL is a
23615 face-override for drawing S. */
23618 #define OPTIONAL_HDC(hdc) HDC hdc,
23619 #define DECLARE_HDC(hdc) HDC hdc;
23620 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
23621 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
23624 #ifndef OPTIONAL_HDC
23625 #define OPTIONAL_HDC(hdc)
23626 #define DECLARE_HDC(hdc)
23627 #define ALLOCATE_HDC(hdc, f)
23628 #define RELEASE_HDC(hdc, f)
23632 init_glyph_string (struct glyph_string
*s
,
23634 XChar2b
*char2b
, struct window
*w
, struct glyph_row
*row
,
23635 enum glyph_row_area area
, int start
, enum draw_glyphs_face hl
)
23637 memset (s
, 0, sizeof *s
);
23639 s
->f
= XFRAME (w
->frame
);
23643 s
->display
= FRAME_X_DISPLAY (s
->f
);
23644 s
->window
= FRAME_X_WINDOW (s
->f
);
23645 s
->char2b
= char2b
;
23649 s
->first_glyph
= row
->glyphs
[area
] + start
;
23650 s
->height
= row
->height
;
23651 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
23652 s
->ybase
= s
->y
+ row
->ascent
;
23656 /* Append the list of glyph strings with head H and tail T to the list
23657 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
23660 append_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
23661 struct glyph_string
*h
, struct glyph_string
*t
)
23675 /* Prepend the list of glyph strings with head H and tail T to the
23676 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
23680 prepend_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
23681 struct glyph_string
*h
, struct glyph_string
*t
)
23695 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
23696 Set *HEAD and *TAIL to the resulting list. */
23699 append_glyph_string (struct glyph_string
**head
, struct glyph_string
**tail
,
23700 struct glyph_string
*s
)
23702 s
->next
= s
->prev
= NULL
;
23703 append_glyph_string_lists (head
, tail
, s
, s
);
23707 /* Get face and two-byte form of character C in face FACE_ID on frame F.
23708 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
23709 make sure that X resources for the face returned are allocated.
23710 Value is a pointer to a realized face that is ready for display if
23711 DISPLAY_P is non-zero. */
23713 static struct face
*
23714 get_char_face_and_encoding (struct frame
*f
, int c
, int face_id
,
23715 XChar2b
*char2b
, int display_p
)
23717 struct face
*face
= FACE_FROM_ID (f
, face_id
);
23722 code
= face
->font
->driver
->encode_char (face
->font
, c
);
23724 if (code
== FONT_INVALID_CODE
)
23727 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
23729 /* Make sure X resources of the face are allocated. */
23730 #ifdef HAVE_X_WINDOWS
23734 eassert (face
!= NULL
);
23735 prepare_face_for_display (f
, face
);
23742 /* Get face and two-byte form of character glyph GLYPH on frame F.
23743 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
23744 a pointer to a realized face that is ready for display. */
23746 static struct face
*
23747 get_glyph_face_and_encoding (struct frame
*f
, struct glyph
*glyph
,
23748 XChar2b
*char2b
, int *two_byte_p
)
23753 eassert (glyph
->type
== CHAR_GLYPH
);
23754 face
= FACE_FROM_ID (f
, glyph
->face_id
);
23756 /* Make sure X resources of the face are allocated. */
23757 eassert (face
!= NULL
);
23758 prepare_face_for_display (f
, face
);
23765 if (CHAR_BYTE8_P (glyph
->u
.ch
))
23766 code
= CHAR_TO_BYTE8 (glyph
->u
.ch
);
23768 code
= face
->font
->driver
->encode_char (face
->font
, glyph
->u
.ch
);
23770 if (code
== FONT_INVALID_CODE
)
23774 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
23779 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
23780 Return 1 if FONT has a glyph for C, otherwise return 0. */
23783 get_char_glyph_code (int c
, struct font
*font
, XChar2b
*char2b
)
23787 if (CHAR_BYTE8_P (c
))
23788 code
= CHAR_TO_BYTE8 (c
);
23790 code
= font
->driver
->encode_char (font
, c
);
23792 if (code
== FONT_INVALID_CODE
)
23794 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
23799 /* Fill glyph string S with composition components specified by S->cmp.
23801 BASE_FACE is the base face of the composition.
23802 S->cmp_from is the index of the first component for S.
23804 OVERLAPS non-zero means S should draw the foreground only, and use
23805 its physical height for clipping. See also draw_glyphs.
23807 Value is the index of a component not in S. */
23810 fill_composite_glyph_string (struct glyph_string
*s
, struct face
*base_face
,
23814 /* For all glyphs of this composition, starting at the offset
23815 S->cmp_from, until we reach the end of the definition or encounter a
23816 glyph that requires the different face, add it to S. */
23821 s
->for_overlaps
= overlaps
;
23824 for (i
= s
->cmp_from
; i
< s
->cmp
->glyph_len
; i
++)
23826 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
23828 /* TAB in a composition means display glyphs with padding space
23829 on the left or right. */
23832 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
->ascii_face
, c
,
23835 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
23842 s
->font
= s
->face
->font
;
23844 else if (s
->face
!= face
)
23852 if (s
->face
== NULL
)
23854 s
->face
= base_face
->ascii_face
;
23855 s
->font
= s
->face
->font
;
23858 /* All glyph strings for the same composition has the same width,
23859 i.e. the width set for the first component of the composition. */
23860 s
->width
= s
->first_glyph
->pixel_width
;
23862 /* If the specified font could not be loaded, use the frame's
23863 default font, but record the fact that we couldn't load it in
23864 the glyph string so that we can draw rectangles for the
23865 characters of the glyph string. */
23866 if (s
->font
== NULL
)
23868 s
->font_not_found_p
= 1;
23869 s
->font
= FRAME_FONT (s
->f
);
23872 /* Adjust base line for subscript/superscript text. */
23873 s
->ybase
+= s
->first_glyph
->voffset
;
23875 /* This glyph string must always be drawn with 16-bit functions. */
23882 fill_gstring_glyph_string (struct glyph_string
*s
, int face_id
,
23883 int start
, int end
, int overlaps
)
23885 struct glyph
*glyph
, *last
;
23886 Lisp_Object lgstring
;
23889 s
->for_overlaps
= overlaps
;
23890 glyph
= s
->row
->glyphs
[s
->area
] + start
;
23891 last
= s
->row
->glyphs
[s
->area
] + end
;
23892 s
->cmp_id
= glyph
->u
.cmp
.id
;
23893 s
->cmp_from
= glyph
->slice
.cmp
.from
;
23894 s
->cmp_to
= glyph
->slice
.cmp
.to
+ 1;
23895 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
23896 lgstring
= composition_gstring_from_id (s
->cmp_id
);
23897 s
->font
= XFONT_OBJECT (LGSTRING_FONT (lgstring
));
23899 while (glyph
< last
23900 && glyph
->u
.cmp
.automatic
23901 && glyph
->u
.cmp
.id
== s
->cmp_id
23902 && s
->cmp_to
== glyph
->slice
.cmp
.from
)
23903 s
->cmp_to
= (glyph
++)->slice
.cmp
.to
+ 1;
23905 for (i
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
23907 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
23908 unsigned code
= LGLYPH_CODE (lglyph
);
23910 STORE_XCHAR2B ((s
->char2b
+ i
), code
>> 8, code
& 0xFF);
23912 s
->width
= composition_gstring_width (lgstring
, s
->cmp_from
, s
->cmp_to
, NULL
);
23913 return glyph
- s
->row
->glyphs
[s
->area
];
23917 /* Fill glyph string S from a sequence glyphs for glyphless characters.
23918 See the comment of fill_glyph_string for arguments.
23919 Value is the index of the first glyph not in S. */
23923 fill_glyphless_glyph_string (struct glyph_string
*s
, int face_id
,
23924 int start
, int end
, int overlaps
)
23926 struct glyph
*glyph
, *last
;
23929 eassert (s
->first_glyph
->type
== GLYPHLESS_GLYPH
);
23930 s
->for_overlaps
= overlaps
;
23931 glyph
= s
->row
->glyphs
[s
->area
] + start
;
23932 last
= s
->row
->glyphs
[s
->area
] + end
;
23933 voffset
= glyph
->voffset
;
23934 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
23935 s
->font
= s
->face
->font
? s
->face
->font
: FRAME_FONT (s
->f
);
23937 s
->width
= glyph
->pixel_width
;
23939 while (glyph
< last
23940 && glyph
->type
== GLYPHLESS_GLYPH
23941 && glyph
->voffset
== voffset
23942 && glyph
->face_id
== face_id
)
23945 s
->width
+= glyph
->pixel_width
;
23948 s
->ybase
+= voffset
;
23949 return glyph
- s
->row
->glyphs
[s
->area
];
23953 /* Fill glyph string S from a sequence of character glyphs.
23955 FACE_ID is the face id of the string. START is the index of the
23956 first glyph to consider, END is the index of the last + 1.
23957 OVERLAPS non-zero means S should draw the foreground only, and use
23958 its physical height for clipping. See also draw_glyphs.
23960 Value is the index of the first glyph not in S. */
23963 fill_glyph_string (struct glyph_string
*s
, int face_id
,
23964 int start
, int end
, int overlaps
)
23966 struct glyph
*glyph
, *last
;
23968 int glyph_not_available_p
;
23970 eassert (s
->f
== XFRAME (s
->w
->frame
));
23971 eassert (s
->nchars
== 0);
23972 eassert (start
>= 0 && end
> start
);
23974 s
->for_overlaps
= overlaps
;
23975 glyph
= s
->row
->glyphs
[s
->area
] + start
;
23976 last
= s
->row
->glyphs
[s
->area
] + end
;
23977 voffset
= glyph
->voffset
;
23978 s
->padding_p
= glyph
->padding_p
;
23979 glyph_not_available_p
= glyph
->glyph_not_available_p
;
23981 while (glyph
< last
23982 && glyph
->type
== CHAR_GLYPH
23983 && glyph
->voffset
== voffset
23984 /* Same face id implies same font, nowadays. */
23985 && glyph
->face_id
== face_id
23986 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
23990 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
23991 s
->char2b
+ s
->nchars
,
23993 s
->two_byte_p
= two_byte_p
;
23995 eassert (s
->nchars
<= end
- start
);
23996 s
->width
+= glyph
->pixel_width
;
23997 if (glyph
++->padding_p
!= s
->padding_p
)
24001 s
->font
= s
->face
->font
;
24003 /* If the specified font could not be loaded, use the frame's font,
24004 but record the fact that we couldn't load it in
24005 S->font_not_found_p so that we can draw rectangles for the
24006 characters of the glyph string. */
24007 if (s
->font
== NULL
|| glyph_not_available_p
)
24009 s
->font_not_found_p
= 1;
24010 s
->font
= FRAME_FONT (s
->f
);
24013 /* Adjust base line for subscript/superscript text. */
24014 s
->ybase
+= voffset
;
24016 eassert (s
->face
&& s
->face
->gc
);
24017 return glyph
- s
->row
->glyphs
[s
->area
];
24021 /* Fill glyph string S from image glyph S->first_glyph. */
24024 fill_image_glyph_string (struct glyph_string
*s
)
24026 eassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
24027 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
24029 s
->slice
= s
->first_glyph
->slice
.img
;
24030 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
24031 s
->font
= s
->face
->font
;
24032 s
->width
= s
->first_glyph
->pixel_width
;
24034 /* Adjust base line for subscript/superscript text. */
24035 s
->ybase
+= s
->first_glyph
->voffset
;
24039 /* Fill glyph string S from a sequence of stretch glyphs.
24041 START is the index of the first glyph to consider,
24042 END is the index of the last + 1.
24044 Value is the index of the first glyph not in S. */
24047 fill_stretch_glyph_string (struct glyph_string
*s
, int start
, int end
)
24049 struct glyph
*glyph
, *last
;
24050 int voffset
, face_id
;
24052 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
24054 glyph
= s
->row
->glyphs
[s
->area
] + start
;
24055 last
= s
->row
->glyphs
[s
->area
] + end
;
24056 face_id
= glyph
->face_id
;
24057 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
24058 s
->font
= s
->face
->font
;
24059 s
->width
= glyph
->pixel_width
;
24061 voffset
= glyph
->voffset
;
24065 && glyph
->type
== STRETCH_GLYPH
24066 && glyph
->voffset
== voffset
24067 && glyph
->face_id
== face_id
);
24069 s
->width
+= glyph
->pixel_width
;
24071 /* Adjust base line for subscript/superscript text. */
24072 s
->ybase
+= voffset
;
24074 /* The case that face->gc == 0 is handled when drawing the glyph
24075 string by calling prepare_face_for_display. */
24077 return glyph
- s
->row
->glyphs
[s
->area
];
24080 static struct font_metrics
*
24081 get_per_char_metric (struct font
*font
, XChar2b
*char2b
)
24083 static struct font_metrics metrics
;
24088 code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
24089 if (code
== FONT_INVALID_CODE
)
24091 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
24096 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
24097 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
24098 assumed to be zero. */
24101 x_get_glyph_overhangs (struct glyph
*glyph
, struct frame
*f
, int *left
, int *right
)
24103 *left
= *right
= 0;
24105 if (glyph
->type
== CHAR_GLYPH
)
24109 struct font_metrics
*pcm
;
24111 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
24112 if (face
->font
&& (pcm
= get_per_char_metric (face
->font
, &char2b
)))
24114 if (pcm
->rbearing
> pcm
->width
)
24115 *right
= pcm
->rbearing
- pcm
->width
;
24116 if (pcm
->lbearing
< 0)
24117 *left
= -pcm
->lbearing
;
24120 else if (glyph
->type
== COMPOSITE_GLYPH
)
24122 if (! glyph
->u
.cmp
.automatic
)
24124 struct composition
*cmp
= composition_table
[glyph
->u
.cmp
.id
];
24126 if (cmp
->rbearing
> cmp
->pixel_width
)
24127 *right
= cmp
->rbearing
- cmp
->pixel_width
;
24128 if (cmp
->lbearing
< 0)
24129 *left
= - cmp
->lbearing
;
24133 Lisp_Object gstring
= composition_gstring_from_id (glyph
->u
.cmp
.id
);
24134 struct font_metrics metrics
;
24136 composition_gstring_width (gstring
, glyph
->slice
.cmp
.from
,
24137 glyph
->slice
.cmp
.to
+ 1, &metrics
);
24138 if (metrics
.rbearing
> metrics
.width
)
24139 *right
= metrics
.rbearing
- metrics
.width
;
24140 if (metrics
.lbearing
< 0)
24141 *left
= - metrics
.lbearing
;
24147 /* Return the index of the first glyph preceding glyph string S that
24148 is overwritten by S because of S's left overhang. Value is -1
24149 if no glyphs are overwritten. */
24152 left_overwritten (struct glyph_string
*s
)
24156 if (s
->left_overhang
)
24159 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
24160 int first
= s
->first_glyph
- glyphs
;
24162 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
24163 x
-= glyphs
[i
].pixel_width
;
24174 /* Return the index of the first glyph preceding glyph string S that
24175 is overwriting S because of its right overhang. Value is -1 if no
24176 glyph in front of S overwrites S. */
24179 left_overwriting (struct glyph_string
*s
)
24182 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
24183 int first
= s
->first_glyph
- glyphs
;
24187 for (i
= first
- 1; i
>= 0; --i
)
24190 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
24193 x
-= glyphs
[i
].pixel_width
;
24200 /* Return the index of the last glyph following glyph string S that is
24201 overwritten by S because of S's right overhang. Value is -1 if
24202 no such glyph is found. */
24205 right_overwritten (struct glyph_string
*s
)
24209 if (s
->right_overhang
)
24212 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
24213 int first
= (s
->first_glyph
- glyphs
24214 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
24215 int end
= s
->row
->used
[s
->area
];
24217 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
24218 x
+= glyphs
[i
].pixel_width
;
24227 /* Return the index of the last glyph following glyph string S that
24228 overwrites S because of its left overhang. Value is negative
24229 if no such glyph is found. */
24232 right_overwriting (struct glyph_string
*s
)
24235 int end
= s
->row
->used
[s
->area
];
24236 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
24237 int first
= (s
->first_glyph
- glyphs
24238 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
24242 for (i
= first
; i
< end
; ++i
)
24245 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
24248 x
+= glyphs
[i
].pixel_width
;
24255 /* Set background width of glyph string S. START is the index of the
24256 first glyph following S. LAST_X is the right-most x-position + 1
24257 in the drawing area. */
24260 set_glyph_string_background_width (struct glyph_string
*s
, int start
, int last_x
)
24262 /* If the face of this glyph string has to be drawn to the end of
24263 the drawing area, set S->extends_to_end_of_line_p. */
24265 if (start
== s
->row
->used
[s
->area
]
24266 && ((s
->row
->fill_line_p
24267 && (s
->hl
== DRAW_NORMAL_TEXT
24268 || s
->hl
== DRAW_IMAGE_RAISED
24269 || s
->hl
== DRAW_IMAGE_SUNKEN
))
24270 || s
->hl
== DRAW_MOUSE_FACE
))
24271 s
->extends_to_end_of_line_p
= 1;
24273 /* If S extends its face to the end of the line, set its
24274 background_width to the distance to the right edge of the drawing
24276 if (s
->extends_to_end_of_line_p
)
24277 s
->background_width
= last_x
- s
->x
+ 1;
24279 s
->background_width
= s
->width
;
24283 /* Compute overhangs and x-positions for glyph string S and its
24284 predecessors, or successors. X is the starting x-position for S.
24285 BACKWARD_P non-zero means process predecessors. */
24288 compute_overhangs_and_x (struct glyph_string
*s
, int x
, int backward_p
)
24294 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
24295 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
24305 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
24306 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
24316 /* The following macros are only called from draw_glyphs below.
24317 They reference the following parameters of that function directly:
24318 `w', `row', `area', and `overlap_p'
24319 as well as the following local variables:
24320 `s', `f', and `hdc' (in W32) */
24323 /* On W32, silently add local `hdc' variable to argument list of
24324 init_glyph_string. */
24325 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
24326 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
24328 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
24329 init_glyph_string (s, char2b, w, row, area, start, hl)
24332 /* Add a glyph string for a stretch glyph to the list of strings
24333 between HEAD and TAIL. START is the index of the stretch glyph in
24334 row area AREA of glyph row ROW. END is the index of the last glyph
24335 in that glyph row area. X is the current output position assigned
24336 to the new glyph string constructed. HL overrides that face of the
24337 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
24338 is the right-most x-position of the drawing area. */
24340 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
24341 and below -- keep them on one line. */
24342 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
24345 s = alloca (sizeof *s); \
24346 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
24347 START = fill_stretch_glyph_string (s, START, END); \
24348 append_glyph_string (&HEAD, &TAIL, s); \
24354 /* Add a glyph string for an image glyph to the list of strings
24355 between HEAD and TAIL. START is the index of the image glyph in
24356 row area AREA of glyph row ROW. END is the index of the last glyph
24357 in that glyph row area. X is the current output position assigned
24358 to the new glyph string constructed. HL overrides that face of the
24359 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
24360 is the right-most x-position of the drawing area. */
24362 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
24365 s = alloca (sizeof *s); \
24366 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
24367 fill_image_glyph_string (s); \
24368 append_glyph_string (&HEAD, &TAIL, s); \
24375 /* Add a glyph string for a sequence of character glyphs to the list
24376 of strings between HEAD and TAIL. START is the index of the first
24377 glyph in row area AREA of glyph row ROW that is part of the new
24378 glyph string. END is the index of the last glyph in that glyph row
24379 area. X is the current output position assigned to the new glyph
24380 string constructed. HL overrides that face of the glyph; e.g. it
24381 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
24382 right-most x-position of the drawing area. */
24384 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
24390 face_id = (row)->glyphs[area][START].face_id; \
24392 s = alloca (sizeof *s); \
24393 char2b = alloca ((END - START) * sizeof *char2b); \
24394 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
24395 append_glyph_string (&HEAD, &TAIL, s); \
24397 START = fill_glyph_string (s, face_id, START, END, overlaps); \
24402 /* Add a glyph string for a composite sequence to the list of strings
24403 between HEAD and TAIL. START is the index of the first glyph in
24404 row area AREA of glyph row ROW that is part of the new glyph
24405 string. END is the index of the last glyph in that glyph row area.
24406 X is the current output position assigned to the new glyph string
24407 constructed. HL overrides that face of the glyph; e.g. it is
24408 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
24409 x-position of the drawing area. */
24411 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
24413 int face_id = (row)->glyphs[area][START].face_id; \
24414 struct face *base_face = FACE_FROM_ID (f, face_id); \
24415 ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id; \
24416 struct composition *cmp = composition_table[cmp_id]; \
24418 struct glyph_string *first_s = NULL; \
24421 char2b = alloca (cmp->glyph_len * sizeof *char2b); \
24423 /* Make glyph_strings for each glyph sequence that is drawable by \
24424 the same face, and append them to HEAD/TAIL. */ \
24425 for (n = 0; n < cmp->glyph_len;) \
24427 s = alloca (sizeof *s); \
24428 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
24429 append_glyph_string (&(HEAD), &(TAIL), s); \
24435 n = fill_composite_glyph_string (s, base_face, overlaps); \
24443 /* Add a glyph string for a glyph-string sequence to the list of strings
24444 between HEAD and TAIL. */
24446 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
24450 Lisp_Object gstring; \
24452 face_id = (row)->glyphs[area][START].face_id; \
24453 gstring = (composition_gstring_from_id \
24454 ((row)->glyphs[area][START].u.cmp.id)); \
24455 s = alloca (sizeof *s); \
24456 char2b = alloca (LGSTRING_GLYPH_LEN (gstring) * sizeof *char2b); \
24457 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
24458 append_glyph_string (&(HEAD), &(TAIL), s); \
24460 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
24464 /* Add a glyph string for a sequence of glyphless character's glyphs
24465 to the list of strings between HEAD and TAIL. The meanings of
24466 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
24468 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
24473 face_id = (row)->glyphs[area][START].face_id; \
24475 s = alloca (sizeof *s); \
24476 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
24477 append_glyph_string (&HEAD, &TAIL, s); \
24479 START = fill_glyphless_glyph_string (s, face_id, START, END, \
24485 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
24486 of AREA of glyph row ROW on window W between indices START and END.
24487 HL overrides the face for drawing glyph strings, e.g. it is
24488 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
24489 x-positions of the drawing area.
24491 This is an ugly monster macro construct because we must use alloca
24492 to allocate glyph strings (because draw_glyphs can be called
24493 asynchronously). */
24495 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
24498 HEAD = TAIL = NULL; \
24499 while (START < END) \
24501 struct glyph *first_glyph = (row)->glyphs[area] + START; \
24502 switch (first_glyph->type) \
24505 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
24509 case COMPOSITE_GLYPH: \
24510 if (first_glyph->u.cmp.automatic) \
24511 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
24514 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
24518 case STRETCH_GLYPH: \
24519 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
24523 case IMAGE_GLYPH: \
24524 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
24528 case GLYPHLESS_GLYPH: \
24529 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
24539 set_glyph_string_background_width (s, START, LAST_X); \
24546 /* Draw glyphs between START and END in AREA of ROW on window W,
24547 starting at x-position X. X is relative to AREA in W. HL is a
24548 face-override with the following meaning:
24550 DRAW_NORMAL_TEXT draw normally
24551 DRAW_CURSOR draw in cursor face
24552 DRAW_MOUSE_FACE draw in mouse face.
24553 DRAW_INVERSE_VIDEO draw in mode line face
24554 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
24555 DRAW_IMAGE_RAISED draw an image with a raised relief around it
24557 If OVERLAPS is non-zero, draw only the foreground of characters and
24558 clip to the physical height of ROW. Non-zero value also defines
24559 the overlapping part to be drawn:
24561 OVERLAPS_PRED overlap with preceding rows
24562 OVERLAPS_SUCC overlap with succeeding rows
24563 OVERLAPS_BOTH overlap with both preceding/succeeding rows
24564 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
24566 Value is the x-position reached, relative to AREA of W. */
24569 draw_glyphs (struct window
*w
, int x
, struct glyph_row
*row
,
24570 enum glyph_row_area area
, ptrdiff_t start
, ptrdiff_t end
,
24571 enum draw_glyphs_face hl
, int overlaps
)
24573 struct glyph_string
*head
, *tail
;
24574 struct glyph_string
*s
;
24575 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
24576 int i
, j
, x_reached
, last_x
, area_left
= 0;
24577 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
24580 ALLOCATE_HDC (hdc
, f
);
24582 /* Let's rather be paranoid than getting a SEGV. */
24583 end
= min (end
, row
->used
[area
]);
24584 start
= clip_to_bounds (0, start
, end
);
24586 /* Translate X to frame coordinates. Set last_x to the right
24587 end of the drawing area. */
24588 if (row
->full_width_p
)
24590 /* X is relative to the left edge of W, without scroll bars
24592 area_left
= WINDOW_LEFT_EDGE_X (w
);
24593 last_x
= (WINDOW_LEFT_EDGE_X (w
) + WINDOW_PIXEL_WIDTH (w
)
24594 - (row
->mode_line_p
? WINDOW_RIGHT_DIVIDER_WIDTH (w
) : 0));
24598 area_left
= window_box_left (w
, area
);
24599 last_x
= area_left
+ window_box_width (w
, area
);
24603 /* Build a doubly-linked list of glyph_string structures between
24604 head and tail from what we have to draw. Note that the macro
24605 BUILD_GLYPH_STRINGS will modify its start parameter. That's
24606 the reason we use a separate variable `i'. */
24608 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
24610 x_reached
= tail
->x
+ tail
->background_width
;
24614 /* If there are any glyphs with lbearing < 0 or rbearing > width in
24615 the row, redraw some glyphs in front or following the glyph
24616 strings built above. */
24617 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
24619 struct glyph_string
*h
, *t
;
24620 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
24621 int mouse_beg_col
IF_LINT (= 0), mouse_end_col
IF_LINT (= 0);
24622 int check_mouse_face
= 0;
24625 /* If mouse highlighting is on, we may need to draw adjacent
24626 glyphs using mouse-face highlighting. */
24627 if (area
== TEXT_AREA
&& row
->mouse_face_p
24628 && hlinfo
->mouse_face_beg_row
>= 0
24629 && hlinfo
->mouse_face_end_row
>= 0)
24631 ptrdiff_t row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
24633 if (row_vpos
>= hlinfo
->mouse_face_beg_row
24634 && row_vpos
<= hlinfo
->mouse_face_end_row
)
24636 check_mouse_face
= 1;
24637 mouse_beg_col
= (row_vpos
== hlinfo
->mouse_face_beg_row
)
24638 ? hlinfo
->mouse_face_beg_col
: 0;
24639 mouse_end_col
= (row_vpos
== hlinfo
->mouse_face_end_row
)
24640 ? hlinfo
->mouse_face_end_col
24641 : row
->used
[TEXT_AREA
];
24645 /* Compute overhangs for all glyph strings. */
24646 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
24647 for (s
= head
; s
; s
= s
->next
)
24648 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
24650 /* Prepend glyph strings for glyphs in front of the first glyph
24651 string that are overwritten because of the first glyph
24652 string's left overhang. The background of all strings
24653 prepended must be drawn because the first glyph string
24655 i
= left_overwritten (head
);
24658 enum draw_glyphs_face overlap_hl
;
24660 /* If this row contains mouse highlighting, attempt to draw
24661 the overlapped glyphs with the correct highlight. This
24662 code fails if the overlap encompasses more than one glyph
24663 and mouse-highlight spans only some of these glyphs.
24664 However, making it work perfectly involves a lot more
24665 code, and I don't know if the pathological case occurs in
24666 practice, so we'll stick to this for now. --- cyd */
24667 if (check_mouse_face
24668 && mouse_beg_col
< start
&& mouse_end_col
> i
)
24669 overlap_hl
= DRAW_MOUSE_FACE
;
24671 overlap_hl
= DRAW_NORMAL_TEXT
;
24673 if (hl
!= overlap_hl
)
24676 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
24677 overlap_hl
, dummy_x
, last_x
);
24679 compute_overhangs_and_x (t
, head
->x
, 1);
24680 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
24681 if (clip_head
== NULL
)
24685 /* Prepend glyph strings for glyphs in front of the first glyph
24686 string that overwrite that glyph string because of their
24687 right overhang. For these strings, only the foreground must
24688 be drawn, because it draws over the glyph string at `head'.
24689 The background must not be drawn because this would overwrite
24690 right overhangs of preceding glyphs for which no glyph
24692 i
= left_overwriting (head
);
24695 enum draw_glyphs_face overlap_hl
;
24697 if (check_mouse_face
24698 && mouse_beg_col
< start
&& mouse_end_col
> i
)
24699 overlap_hl
= DRAW_MOUSE_FACE
;
24701 overlap_hl
= DRAW_NORMAL_TEXT
;
24703 if (hl
== overlap_hl
|| clip_head
== NULL
)
24705 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
24706 overlap_hl
, dummy_x
, last_x
);
24707 for (s
= h
; s
; s
= s
->next
)
24708 s
->background_filled_p
= 1;
24709 compute_overhangs_and_x (t
, head
->x
, 1);
24710 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
24713 /* Append glyphs strings for glyphs following the last glyph
24714 string tail that are overwritten by tail. The background of
24715 these strings has to be drawn because tail's foreground draws
24717 i
= right_overwritten (tail
);
24720 enum draw_glyphs_face overlap_hl
;
24722 if (check_mouse_face
24723 && mouse_beg_col
< i
&& mouse_end_col
> end
)
24724 overlap_hl
= DRAW_MOUSE_FACE
;
24726 overlap_hl
= DRAW_NORMAL_TEXT
;
24728 if (hl
!= overlap_hl
)
24730 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
24731 overlap_hl
, x
, last_x
);
24732 /* Because BUILD_GLYPH_STRINGS updates the first argument,
24733 we don't have `end = i;' here. */
24734 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
24735 append_glyph_string_lists (&head
, &tail
, h
, t
);
24736 if (clip_tail
== NULL
)
24740 /* Append glyph strings for glyphs following the last glyph
24741 string tail that overwrite tail. The foreground of such
24742 glyphs has to be drawn because it writes into the background
24743 of tail. The background must not be drawn because it could
24744 paint over the foreground of following glyphs. */
24745 i
= right_overwriting (tail
);
24748 enum draw_glyphs_face overlap_hl
;
24749 if (check_mouse_face
24750 && mouse_beg_col
< i
&& mouse_end_col
> end
)
24751 overlap_hl
= DRAW_MOUSE_FACE
;
24753 overlap_hl
= DRAW_NORMAL_TEXT
;
24755 if (hl
== overlap_hl
|| clip_tail
== NULL
)
24757 i
++; /* We must include the Ith glyph. */
24758 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
24759 overlap_hl
, x
, last_x
);
24760 for (s
= h
; s
; s
= s
->next
)
24761 s
->background_filled_p
= 1;
24762 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
24763 append_glyph_string_lists (&head
, &tail
, h
, t
);
24765 if (clip_head
|| clip_tail
)
24766 for (s
= head
; s
; s
= s
->next
)
24768 s
->clip_head
= clip_head
;
24769 s
->clip_tail
= clip_tail
;
24773 /* Draw all strings. */
24774 for (s
= head
; s
; s
= s
->next
)
24775 FRAME_RIF (f
)->draw_glyph_string (s
);
24778 /* When focus a sole frame and move horizontally, this sets on_p to 0
24779 causing a failure to erase prev cursor position. */
24780 if (area
== TEXT_AREA
24781 && !row
->full_width_p
24782 /* When drawing overlapping rows, only the glyph strings'
24783 foreground is drawn, which doesn't erase a cursor
24787 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
24788 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
24789 : (tail
? tail
->x
+ tail
->background_width
: x
));
24793 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
24794 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
24798 /* Value is the x-position up to which drawn, relative to AREA of W.
24799 This doesn't include parts drawn because of overhangs. */
24800 if (row
->full_width_p
)
24801 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
24803 x_reached
-= area_left
;
24805 RELEASE_HDC (hdc
, f
);
24810 /* Expand row matrix if too narrow. Don't expand if area
24813 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
24815 if (!it->f->fonts_changed \
24816 && (it->glyph_row->glyphs[area] \
24817 < it->glyph_row->glyphs[area + 1])) \
24819 it->w->ncols_scale_factor++; \
24820 it->f->fonts_changed = 1; \
24824 /* Store one glyph for IT->char_to_display in IT->glyph_row.
24825 Called from x_produce_glyphs when IT->glyph_row is non-null. */
24828 append_glyph (struct it
*it
)
24830 struct glyph
*glyph
;
24831 enum glyph_row_area area
= it
->area
;
24833 eassert (it
->glyph_row
);
24834 eassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
24836 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24837 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24839 /* If the glyph row is reversed, we need to prepend the glyph
24840 rather than append it. */
24841 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24845 /* Make room for the additional glyph. */
24846 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
24848 glyph
= it
->glyph_row
->glyphs
[area
];
24850 glyph
->charpos
= CHARPOS (it
->position
);
24851 glyph
->object
= it
->object
;
24852 if (it
->pixel_width
> 0)
24854 glyph
->pixel_width
= it
->pixel_width
;
24855 glyph
->padding_p
= 0;
24859 /* Assure at least 1-pixel width. Otherwise, cursor can't
24860 be displayed correctly. */
24861 glyph
->pixel_width
= 1;
24862 glyph
->padding_p
= 1;
24864 glyph
->ascent
= it
->ascent
;
24865 glyph
->descent
= it
->descent
;
24866 glyph
->voffset
= it
->voffset
;
24867 glyph
->type
= CHAR_GLYPH
;
24868 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24869 glyph
->multibyte_p
= it
->multibyte_p
;
24870 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24872 /* In R2L rows, the left and the right box edges need to be
24873 drawn in reverse direction. */
24874 glyph
->right_box_line_p
= it
->start_of_box_run_p
;
24875 glyph
->left_box_line_p
= it
->end_of_box_run_p
;
24879 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24880 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24882 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
24883 || it
->phys_descent
> it
->descent
);
24884 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
24885 glyph
->face_id
= it
->face_id
;
24886 glyph
->u
.ch
= it
->char_to_display
;
24887 glyph
->slice
.img
= null_glyph_slice
;
24888 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24891 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24892 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24894 glyph
->bidi_type
= it
->bidi_it
.type
;
24898 glyph
->resolved_level
= 0;
24899 glyph
->bidi_type
= UNKNOWN_BT
;
24901 ++it
->glyph_row
->used
[area
];
24904 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24907 /* Store one glyph for the composition IT->cmp_it.id in
24908 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
24912 append_composite_glyph (struct it
*it
)
24914 struct glyph
*glyph
;
24915 enum glyph_row_area area
= it
->area
;
24917 eassert (it
->glyph_row
);
24919 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24920 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24922 /* If the glyph row is reversed, we need to prepend the glyph
24923 rather than append it. */
24924 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
24928 /* Make room for the new glyph. */
24929 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
24931 glyph
= it
->glyph_row
->glyphs
[it
->area
];
24933 glyph
->charpos
= it
->cmp_it
.charpos
;
24934 glyph
->object
= it
->object
;
24935 glyph
->pixel_width
= it
->pixel_width
;
24936 glyph
->ascent
= it
->ascent
;
24937 glyph
->descent
= it
->descent
;
24938 glyph
->voffset
= it
->voffset
;
24939 glyph
->type
= COMPOSITE_GLYPH
;
24940 if (it
->cmp_it
.ch
< 0)
24942 glyph
->u
.cmp
.automatic
= 0;
24943 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
24944 glyph
->slice
.cmp
.from
= glyph
->slice
.cmp
.to
= 0;
24948 glyph
->u
.cmp
.automatic
= 1;
24949 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
24950 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
24951 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
24953 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24954 glyph
->multibyte_p
= it
->multibyte_p
;
24955 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24957 /* In R2L rows, the left and the right box edges need to be
24958 drawn in reverse direction. */
24959 glyph
->right_box_line_p
= it
->start_of_box_run_p
;
24960 glyph
->left_box_line_p
= it
->end_of_box_run_p
;
24964 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24965 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24967 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
24968 || it
->phys_descent
> it
->descent
);
24969 glyph
->padding_p
= 0;
24970 glyph
->glyph_not_available_p
= 0;
24971 glyph
->face_id
= it
->face_id
;
24972 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24975 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24976 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24978 glyph
->bidi_type
= it
->bidi_it
.type
;
24980 ++it
->glyph_row
->used
[area
];
24983 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24987 /* Change IT->ascent and IT->height according to the setting of
24991 take_vertical_position_into_account (struct it
*it
)
24995 if (it
->voffset
< 0)
24996 /* Increase the ascent so that we can display the text higher
24998 it
->ascent
-= it
->voffset
;
25000 /* Increase the descent so that we can display the text lower
25002 it
->descent
+= it
->voffset
;
25007 /* Produce glyphs/get display metrics for the image IT is loaded with.
25008 See the description of struct display_iterator in dispextern.h for
25009 an overview of struct display_iterator. */
25012 produce_image_glyph (struct it
*it
)
25016 int glyph_ascent
, crop
;
25017 struct glyph_slice slice
;
25019 eassert (it
->what
== IT_IMAGE
);
25021 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
25023 /* Make sure X resources of the face is loaded. */
25024 prepare_face_for_display (it
->f
, face
);
25026 if (it
->image_id
< 0)
25028 /* Fringe bitmap. */
25029 it
->ascent
= it
->phys_ascent
= 0;
25030 it
->descent
= it
->phys_descent
= 0;
25031 it
->pixel_width
= 0;
25036 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
25038 /* Make sure X resources of the image is loaded. */
25039 prepare_image_for_display (it
->f
, img
);
25041 slice
.x
= slice
.y
= 0;
25042 slice
.width
= img
->width
;
25043 slice
.height
= img
->height
;
25045 if (INTEGERP (it
->slice
.x
))
25046 slice
.x
= XINT (it
->slice
.x
);
25047 else if (FLOATP (it
->slice
.x
))
25048 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
25050 if (INTEGERP (it
->slice
.y
))
25051 slice
.y
= XINT (it
->slice
.y
);
25052 else if (FLOATP (it
->slice
.y
))
25053 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
25055 if (INTEGERP (it
->slice
.width
))
25056 slice
.width
= XINT (it
->slice
.width
);
25057 else if (FLOATP (it
->slice
.width
))
25058 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
25060 if (INTEGERP (it
->slice
.height
))
25061 slice
.height
= XINT (it
->slice
.height
);
25062 else if (FLOATP (it
->slice
.height
))
25063 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
25065 if (slice
.x
>= img
->width
)
25066 slice
.x
= img
->width
;
25067 if (slice
.y
>= img
->height
)
25068 slice
.y
= img
->height
;
25069 if (slice
.x
+ slice
.width
>= img
->width
)
25070 slice
.width
= img
->width
- slice
.x
;
25071 if (slice
.y
+ slice
.height
> img
->height
)
25072 slice
.height
= img
->height
- slice
.y
;
25074 if (slice
.width
== 0 || slice
.height
== 0)
25077 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
25079 it
->descent
= slice
.height
- glyph_ascent
;
25081 it
->descent
+= img
->vmargin
;
25082 if (slice
.y
+ slice
.height
== img
->height
)
25083 it
->descent
+= img
->vmargin
;
25084 it
->phys_descent
= it
->descent
;
25086 it
->pixel_width
= slice
.width
;
25088 it
->pixel_width
+= img
->hmargin
;
25089 if (slice
.x
+ slice
.width
== img
->width
)
25090 it
->pixel_width
+= img
->hmargin
;
25092 /* It's quite possible for images to have an ascent greater than
25093 their height, so don't get confused in that case. */
25094 if (it
->descent
< 0)
25099 if (face
->box
!= FACE_NO_BOX
)
25101 if (face
->box_line_width
> 0)
25104 it
->ascent
+= face
->box_line_width
;
25105 if (slice
.y
+ slice
.height
== img
->height
)
25106 it
->descent
+= face
->box_line_width
;
25109 if (it
->start_of_box_run_p
&& slice
.x
== 0)
25110 it
->pixel_width
+= eabs (face
->box_line_width
);
25111 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
25112 it
->pixel_width
+= eabs (face
->box_line_width
);
25115 take_vertical_position_into_account (it
);
25117 /* Automatically crop wide image glyphs at right edge so we can
25118 draw the cursor on same display row. */
25119 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
25120 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
25122 it
->pixel_width
-= crop
;
25123 slice
.width
-= crop
;
25128 struct glyph
*glyph
;
25129 enum glyph_row_area area
= it
->area
;
25131 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
25132 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
25134 glyph
->charpos
= CHARPOS (it
->position
);
25135 glyph
->object
= it
->object
;
25136 glyph
->pixel_width
= it
->pixel_width
;
25137 glyph
->ascent
= glyph_ascent
;
25138 glyph
->descent
= it
->descent
;
25139 glyph
->voffset
= it
->voffset
;
25140 glyph
->type
= IMAGE_GLYPH
;
25141 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
25142 glyph
->multibyte_p
= it
->multibyte_p
;
25143 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
25145 /* In R2L rows, the left and the right box edges need to be
25146 drawn in reverse direction. */
25147 glyph
->right_box_line_p
= it
->start_of_box_run_p
;
25148 glyph
->left_box_line_p
= it
->end_of_box_run_p
;
25152 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
25153 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
25155 glyph
->overlaps_vertically_p
= 0;
25156 glyph
->padding_p
= 0;
25157 glyph
->glyph_not_available_p
= 0;
25158 glyph
->face_id
= it
->face_id
;
25159 glyph
->u
.img_id
= img
->id
;
25160 glyph
->slice
.img
= slice
;
25161 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
25164 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
25165 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
25167 glyph
->bidi_type
= it
->bidi_it
.type
;
25169 ++it
->glyph_row
->used
[area
];
25172 IT_EXPAND_MATRIX_WIDTH (it
, area
);
25177 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
25178 of the glyph, WIDTH and HEIGHT are the width and height of the
25179 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
25182 append_stretch_glyph (struct it
*it
, Lisp_Object object
,
25183 int width
, int height
, int ascent
)
25185 struct glyph
*glyph
;
25186 enum glyph_row_area area
= it
->area
;
25188 eassert (ascent
>= 0 && ascent
<= height
);
25190 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
25191 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
25193 /* If the glyph row is reversed, we need to prepend the glyph
25194 rather than append it. */
25195 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
25199 /* Make room for the additional glyph. */
25200 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
25202 glyph
= it
->glyph_row
->glyphs
[area
];
25204 glyph
->charpos
= CHARPOS (it
->position
);
25205 glyph
->object
= object
;
25206 glyph
->pixel_width
= width
;
25207 glyph
->ascent
= ascent
;
25208 glyph
->descent
= height
- ascent
;
25209 glyph
->voffset
= it
->voffset
;
25210 glyph
->type
= STRETCH_GLYPH
;
25211 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
25212 glyph
->multibyte_p
= it
->multibyte_p
;
25213 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
25215 /* In R2L rows, the left and the right box edges need to be
25216 drawn in reverse direction. */
25217 glyph
->right_box_line_p
= it
->start_of_box_run_p
;
25218 glyph
->left_box_line_p
= it
->end_of_box_run_p
;
25222 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
25223 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
25225 glyph
->overlaps_vertically_p
= 0;
25226 glyph
->padding_p
= 0;
25227 glyph
->glyph_not_available_p
= 0;
25228 glyph
->face_id
= it
->face_id
;
25229 glyph
->u
.stretch
.ascent
= ascent
;
25230 glyph
->u
.stretch
.height
= height
;
25231 glyph
->slice
.img
= null_glyph_slice
;
25232 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
25235 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
25236 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
25238 glyph
->bidi_type
= it
->bidi_it
.type
;
25242 glyph
->resolved_level
= 0;
25243 glyph
->bidi_type
= UNKNOWN_BT
;
25245 ++it
->glyph_row
->used
[area
];
25248 IT_EXPAND_MATRIX_WIDTH (it
, area
);
25251 #endif /* HAVE_WINDOW_SYSTEM */
25253 /* Produce a stretch glyph for iterator IT. IT->object is the value
25254 of the glyph property displayed. The value must be a list
25255 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
25258 1. `:width WIDTH' specifies that the space should be WIDTH *
25259 canonical char width wide. WIDTH may be an integer or floating
25262 2. `:relative-width FACTOR' specifies that the width of the stretch
25263 should be computed from the width of the first character having the
25264 `glyph' property, and should be FACTOR times that width.
25266 3. `:align-to HPOS' specifies that the space should be wide enough
25267 to reach HPOS, a value in canonical character units.
25269 Exactly one of the above pairs must be present.
25271 4. `:height HEIGHT' specifies that the height of the stretch produced
25272 should be HEIGHT, measured in canonical character units.
25274 5. `:relative-height FACTOR' specifies that the height of the
25275 stretch should be FACTOR times the height of the characters having
25276 the glyph property.
25278 Either none or exactly one of 4 or 5 must be present.
25280 6. `:ascent ASCENT' specifies that ASCENT percent of the height
25281 of the stretch should be used for the ascent of the stretch.
25282 ASCENT must be in the range 0 <= ASCENT <= 100. */
25285 produce_stretch_glyph (struct it
*it
)
25287 /* (space :width WIDTH :height HEIGHT ...) */
25288 Lisp_Object prop
, plist
;
25289 int width
= 0, height
= 0, align_to
= -1;
25290 int zero_width_ok_p
= 0;
25292 struct font
*font
= NULL
;
25294 #ifdef HAVE_WINDOW_SYSTEM
25296 int zero_height_ok_p
= 0;
25298 if (FRAME_WINDOW_P (it
->f
))
25300 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
25301 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
25302 prepare_face_for_display (it
->f
, face
);
25306 /* List should start with `space'. */
25307 eassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
25308 plist
= XCDR (it
->object
);
25310 /* Compute the width of the stretch. */
25311 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
25312 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
25314 /* Absolute width `:width WIDTH' specified and valid. */
25315 zero_width_ok_p
= 1;
25318 #ifdef HAVE_WINDOW_SYSTEM
25319 else if (FRAME_WINDOW_P (it
->f
)
25320 && (prop
= Fplist_get (plist
, QCrelative_width
), NUMVAL (prop
) > 0))
25322 /* Relative width `:relative-width FACTOR' specified and valid.
25323 Compute the width of the characters having the `glyph'
25326 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
25329 if (it
->multibyte_p
)
25330 it2
.c
= it2
.char_to_display
= STRING_CHAR_AND_LENGTH (p
, it2
.len
);
25333 it2
.c
= it2
.char_to_display
= *p
, it2
.len
= 1;
25334 if (! ASCII_CHAR_P (it2
.c
))
25335 it2
.char_to_display
= BYTE8_TO_CHAR (it2
.c
);
25338 it2
.glyph_row
= NULL
;
25339 it2
.what
= IT_CHARACTER
;
25340 x_produce_glyphs (&it2
);
25341 width
= NUMVAL (prop
) * it2
.pixel_width
;
25343 #endif /* HAVE_WINDOW_SYSTEM */
25344 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
25345 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
25347 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
25348 align_to
= (align_to
< 0
25350 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
25351 else if (align_to
< 0)
25352 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
25353 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
25354 zero_width_ok_p
= 1;
25357 /* Nothing specified -> width defaults to canonical char width. */
25358 width
= FRAME_COLUMN_WIDTH (it
->f
);
25360 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
25363 #ifdef HAVE_WINDOW_SYSTEM
25364 /* Compute height. */
25365 if (FRAME_WINDOW_P (it
->f
))
25367 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
25368 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
25371 zero_height_ok_p
= 1;
25373 else if (prop
= Fplist_get (plist
, QCrelative_height
),
25375 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
25377 height
= FONT_HEIGHT (font
);
25379 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
25382 /* Compute percentage of height used for ascent. If
25383 `:ascent ASCENT' is present and valid, use that. Otherwise,
25384 derive the ascent from the font in use. */
25385 if (prop
= Fplist_get (plist
, QCascent
),
25386 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
25387 ascent
= height
* NUMVAL (prop
) / 100.0;
25388 else if (!NILP (prop
)
25389 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
25390 ascent
= min (max (0, (int)tem
), height
);
25392 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
25395 #endif /* HAVE_WINDOW_SYSTEM */
25398 if (width
> 0 && it
->line_wrap
!= TRUNCATE
25399 && it
->current_x
+ width
> it
->last_visible_x
)
25401 width
= it
->last_visible_x
- it
->current_x
;
25402 #ifdef HAVE_WINDOW_SYSTEM
25403 /* Subtract one more pixel from the stretch width, but only on
25404 GUI frames, since on a TTY each glyph is one "pixel" wide. */
25405 width
-= FRAME_WINDOW_P (it
->f
);
25409 if (width
> 0 && height
> 0 && it
->glyph_row
)
25411 Lisp_Object o_object
= it
->object
;
25412 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
25415 if (!STRINGP (object
))
25416 object
= it
->w
->contents
;
25417 #ifdef HAVE_WINDOW_SYSTEM
25418 if (FRAME_WINDOW_P (it
->f
))
25419 append_stretch_glyph (it
, object
, width
, height
, ascent
);
25423 it
->object
= object
;
25424 it
->char_to_display
= ' ';
25425 it
->pixel_width
= it
->len
= 1;
25427 tty_append_glyph (it
);
25428 it
->object
= o_object
;
25432 it
->pixel_width
= width
;
25433 #ifdef HAVE_WINDOW_SYSTEM
25434 if (FRAME_WINDOW_P (it
->f
))
25436 it
->ascent
= it
->phys_ascent
= ascent
;
25437 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
25438 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
25439 take_vertical_position_into_account (it
);
25443 it
->nglyphs
= width
;
25446 /* Get information about special display element WHAT in an
25447 environment described by IT. WHAT is one of IT_TRUNCATION or
25448 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
25449 non-null glyph_row member. This function ensures that fields like
25450 face_id, c, len of IT are left untouched. */
25453 produce_special_glyphs (struct it
*it
, enum display_element_type what
)
25460 temp_it
.object
= make_number (0);
25461 memset (&temp_it
.current
, 0, sizeof temp_it
.current
);
25463 if (what
== IT_CONTINUATION
)
25465 /* Continuation glyph. For R2L lines, we mirror it by hand. */
25466 if (it
->bidi_it
.paragraph_dir
== R2L
)
25467 SET_GLYPH_FROM_CHAR (glyph
, '/');
25469 SET_GLYPH_FROM_CHAR (glyph
, '\\');
25471 && (gc
= DISP_CONTINUE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
25473 /* FIXME: Should we mirror GC for R2L lines? */
25474 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
25475 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
25478 else if (what
== IT_TRUNCATION
)
25480 /* Truncation glyph. */
25481 SET_GLYPH_FROM_CHAR (glyph
, '$');
25483 && (gc
= DISP_TRUNC_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
25485 /* FIXME: Should we mirror GC for R2L lines? */
25486 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
25487 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
25493 #ifdef HAVE_WINDOW_SYSTEM
25494 /* On a GUI frame, when the right fringe (left fringe for R2L rows)
25495 is turned off, we precede the truncation/continuation glyphs by a
25496 stretch glyph whose width is computed such that these special
25497 glyphs are aligned at the window margin, even when very different
25498 fonts are used in different glyph rows. */
25499 if (FRAME_WINDOW_P (temp_it
.f
)
25500 /* init_iterator calls this with it->glyph_row == NULL, and it
25501 wants only the pixel width of the truncation/continuation
25503 && temp_it
.glyph_row
25504 /* insert_left_trunc_glyphs calls us at the beginning of the
25505 row, and it has its own calculation of the stretch glyph
25507 && temp_it
.glyph_row
->used
[TEXT_AREA
] > 0
25508 && (temp_it
.glyph_row
->reversed_p
25509 ? WINDOW_LEFT_FRINGE_WIDTH (temp_it
.w
)
25510 : WINDOW_RIGHT_FRINGE_WIDTH (temp_it
.w
)) == 0)
25512 int stretch_width
= temp_it
.last_visible_x
- temp_it
.current_x
;
25514 if (stretch_width
> 0)
25516 struct face
*face
= FACE_FROM_ID (temp_it
.f
, temp_it
.face_id
);
25517 struct font
*font
=
25518 face
->font
? face
->font
: FRAME_FONT (temp_it
.f
);
25519 int stretch_ascent
=
25520 (((temp_it
.ascent
+ temp_it
.descent
)
25521 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
25523 append_stretch_glyph (&temp_it
, make_number (0), stretch_width
,
25524 temp_it
.ascent
+ temp_it
.descent
,
25531 temp_it
.what
= IT_CHARACTER
;
25533 temp_it
.c
= temp_it
.char_to_display
= GLYPH_CHAR (glyph
);
25534 temp_it
.face_id
= GLYPH_FACE (glyph
);
25535 temp_it
.len
= CHAR_BYTES (temp_it
.c
);
25537 PRODUCE_GLYPHS (&temp_it
);
25538 it
->pixel_width
= temp_it
.pixel_width
;
25539 it
->nglyphs
= temp_it
.pixel_width
;
25542 #ifdef HAVE_WINDOW_SYSTEM
25544 /* Calculate line-height and line-spacing properties.
25545 An integer value specifies explicit pixel value.
25546 A float value specifies relative value to current face height.
25547 A cons (float . face-name) specifies relative value to
25548 height of specified face font.
25550 Returns height in pixels, or nil. */
25554 calc_line_height_property (struct it
*it
, Lisp_Object val
, struct font
*font
,
25555 int boff
, int override
)
25557 Lisp_Object face_name
= Qnil
;
25558 int ascent
, descent
, height
;
25560 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
25565 face_name
= XCAR (val
);
25567 if (!NUMBERP (val
))
25568 val
= make_number (1);
25569 if (NILP (face_name
))
25571 height
= it
->ascent
+ it
->descent
;
25576 if (NILP (face_name
))
25578 font
= FRAME_FONT (it
->f
);
25579 boff
= FRAME_BASELINE_OFFSET (it
->f
);
25581 else if (EQ (face_name
, Qt
))
25590 face_id
= lookup_named_face (it
->f
, face_name
, 0);
25592 return make_number (-1);
25594 face
= FACE_FROM_ID (it
->f
, face_id
);
25597 return make_number (-1);
25598 boff
= font
->baseline_offset
;
25599 if (font
->vertical_centering
)
25600 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
25603 ascent
= FONT_BASE (font
) + boff
;
25604 descent
= FONT_DESCENT (font
) - boff
;
25608 it
->override_ascent
= ascent
;
25609 it
->override_descent
= descent
;
25610 it
->override_boff
= boff
;
25613 height
= ascent
+ descent
;
25617 height
= (int)(XFLOAT_DATA (val
) * height
);
25618 else if (INTEGERP (val
))
25619 height
*= XINT (val
);
25621 return make_number (height
);
25625 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
25626 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
25627 and only if this is for a character for which no font was found.
25629 If the display method (it->glyphless_method) is
25630 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
25631 length of the acronym or the hexadecimal string, UPPER_XOFF and
25632 UPPER_YOFF are pixel offsets for the upper part of the string,
25633 LOWER_XOFF and LOWER_YOFF are for the lower part.
25635 For the other display methods, LEN through LOWER_YOFF are zero. */
25638 append_glyphless_glyph (struct it
*it
, int face_id
, int for_no_font
, int len
,
25639 short upper_xoff
, short upper_yoff
,
25640 short lower_xoff
, short lower_yoff
)
25642 struct glyph
*glyph
;
25643 enum glyph_row_area area
= it
->area
;
25645 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
25646 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
25648 /* If the glyph row is reversed, we need to prepend the glyph
25649 rather than append it. */
25650 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
25654 /* Make room for the additional glyph. */
25655 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
25657 glyph
= it
->glyph_row
->glyphs
[area
];
25659 glyph
->charpos
= CHARPOS (it
->position
);
25660 glyph
->object
= it
->object
;
25661 glyph
->pixel_width
= it
->pixel_width
;
25662 glyph
->ascent
= it
->ascent
;
25663 glyph
->descent
= it
->descent
;
25664 glyph
->voffset
= it
->voffset
;
25665 glyph
->type
= GLYPHLESS_GLYPH
;
25666 glyph
->u
.glyphless
.method
= it
->glyphless_method
;
25667 glyph
->u
.glyphless
.for_no_font
= for_no_font
;
25668 glyph
->u
.glyphless
.len
= len
;
25669 glyph
->u
.glyphless
.ch
= it
->c
;
25670 glyph
->slice
.glyphless
.upper_xoff
= upper_xoff
;
25671 glyph
->slice
.glyphless
.upper_yoff
= upper_yoff
;
25672 glyph
->slice
.glyphless
.lower_xoff
= lower_xoff
;
25673 glyph
->slice
.glyphless
.lower_yoff
= lower_yoff
;
25674 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
25675 glyph
->multibyte_p
= it
->multibyte_p
;
25676 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
25678 /* In R2L rows, the left and the right box edges need to be
25679 drawn in reverse direction. */
25680 glyph
->right_box_line_p
= it
->start_of_box_run_p
;
25681 glyph
->left_box_line_p
= it
->end_of_box_run_p
;
25685 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
25686 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
25688 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
25689 || it
->phys_descent
> it
->descent
);
25690 glyph
->padding_p
= 0;
25691 glyph
->glyph_not_available_p
= 0;
25692 glyph
->face_id
= face_id
;
25693 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
25696 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
25697 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
25699 glyph
->bidi_type
= it
->bidi_it
.type
;
25701 ++it
->glyph_row
->used
[area
];
25704 IT_EXPAND_MATRIX_WIDTH (it
, area
);
25708 /* Produce a glyph for a glyphless character for iterator IT.
25709 IT->glyphless_method specifies which method to use for displaying
25710 the character. See the description of enum
25711 glyphless_display_method in dispextern.h for the detail.
25713 FOR_NO_FONT is nonzero if and only if this is for a character for
25714 which no font was found. ACRONYM, if non-nil, is an acronym string
25715 for the character. */
25718 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
25723 int base_width
, base_height
, width
, height
;
25724 short upper_xoff
, upper_yoff
, lower_xoff
, lower_yoff
;
25727 /* Get the metrics of the base font. We always refer to the current
25729 face
= FACE_FROM_ID (it
->f
, it
->face_id
)->ascii_face
;
25730 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
25731 it
->ascent
= FONT_BASE (font
) + font
->baseline_offset
;
25732 it
->descent
= FONT_DESCENT (font
) - font
->baseline_offset
;
25733 base_height
= it
->ascent
+ it
->descent
;
25734 base_width
= font
->average_width
;
25736 face_id
= merge_glyphless_glyph_face (it
);
25738 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
25740 it
->pixel_width
= THIN_SPACE_WIDTH
;
25742 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
25744 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
25746 width
= CHAR_WIDTH (it
->c
);
25749 else if (width
> 4)
25751 it
->pixel_width
= base_width
* width
;
25753 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
25759 unsigned int code
[6];
25761 int ascent
, descent
;
25762 struct font_metrics metrics_upper
, metrics_lower
;
25764 face
= FACE_FROM_ID (it
->f
, face_id
);
25765 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
25766 prepare_face_for_display (it
->f
, face
);
25768 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
25770 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
25771 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
25772 if (CONSP (acronym
))
25773 acronym
= XCAR (acronym
);
25774 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
25778 eassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
25779 sprintf (buf
, "%0*X", it
->c
< 0x10000 ? 4 : 6, it
->c
);
25782 for (len
= 0; str
[len
] && ASCII_CHAR_P (str
[len
]) && len
< 6; len
++)
25783 code
[len
] = font
->driver
->encode_char (font
, str
[len
]);
25784 upper_len
= (len
+ 1) / 2;
25785 font
->driver
->text_extents (font
, code
, upper_len
,
25787 font
->driver
->text_extents (font
, code
+ upper_len
, len
- upper_len
,
25792 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
25793 width
= max (metrics_upper
.width
, metrics_lower
.width
) + 4;
25794 upper_xoff
= upper_yoff
= 2; /* the typical case */
25795 if (base_width
>= width
)
25797 /* Align the upper to the left, the lower to the right. */
25798 it
->pixel_width
= base_width
;
25799 lower_xoff
= base_width
- 2 - metrics_lower
.width
;
25803 /* Center the shorter one. */
25804 it
->pixel_width
= width
;
25805 if (metrics_upper
.width
>= metrics_lower
.width
)
25806 lower_xoff
= (width
- metrics_lower
.width
) / 2;
25809 /* FIXME: This code doesn't look right. It formerly was
25810 missing the "lower_xoff = 0;", which couldn't have
25811 been right since it left lower_xoff uninitialized. */
25813 upper_xoff
= (width
- metrics_upper
.width
) / 2;
25817 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
25818 top, bottom, and between upper and lower strings. */
25819 height
= (metrics_upper
.ascent
+ metrics_upper
.descent
25820 + metrics_lower
.ascent
+ metrics_lower
.descent
) + 5;
25821 /* Center vertically.
25822 H:base_height, D:base_descent
25823 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
25825 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
25826 descent = D - H/2 + h/2;
25827 lower_yoff = descent - 2 - ld;
25828 upper_yoff = lower_yoff - la - 1 - ud; */
25829 ascent
= - (it
->descent
- (base_height
+ height
+ 1) / 2);
25830 descent
= it
->descent
- (base_height
- height
) / 2;
25831 lower_yoff
= descent
- 2 - metrics_lower
.descent
;
25832 upper_yoff
= (lower_yoff
- metrics_lower
.ascent
- 1
25833 - metrics_upper
.descent
);
25834 /* Don't make the height shorter than the base height. */
25835 if (height
> base_height
)
25837 it
->ascent
= ascent
;
25838 it
->descent
= descent
;
25842 it
->phys_ascent
= it
->ascent
;
25843 it
->phys_descent
= it
->descent
;
25845 append_glyphless_glyph (it
, face_id
, for_no_font
, len
,
25846 upper_xoff
, upper_yoff
,
25847 lower_xoff
, lower_yoff
);
25849 take_vertical_position_into_account (it
);
25854 Produce glyphs/get display metrics for the display element IT is
25855 loaded with. See the description of struct it in dispextern.h
25856 for an overview of struct it. */
25859 x_produce_glyphs (struct it
*it
)
25861 int extra_line_spacing
= it
->extra_line_spacing
;
25863 it
->glyph_not_available_p
= 0;
25865 if (it
->what
== IT_CHARACTER
)
25868 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
25869 struct font
*font
= face
->font
;
25870 struct font_metrics
*pcm
= NULL
;
25871 int boff
; /* Baseline offset. */
25875 /* When no suitable font is found, display this character by
25876 the method specified in the first extra slot of
25877 Vglyphless_char_display. */
25878 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
25880 eassert (it
->what
== IT_GLYPHLESS
);
25881 produce_glyphless_glyph (it
, 1, STRINGP (acronym
) ? acronym
: Qnil
);
25885 boff
= font
->baseline_offset
;
25886 if (font
->vertical_centering
)
25887 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
25889 if (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t')
25895 if (it
->override_ascent
>= 0)
25897 it
->ascent
= it
->override_ascent
;
25898 it
->descent
= it
->override_descent
;
25899 boff
= it
->override_boff
;
25903 it
->ascent
= FONT_BASE (font
) + boff
;
25904 it
->descent
= FONT_DESCENT (font
) - boff
;
25907 if (get_char_glyph_code (it
->char_to_display
, font
, &char2b
))
25909 pcm
= get_per_char_metric (font
, &char2b
);
25910 if (pcm
->width
== 0
25911 && pcm
->rbearing
== 0 && pcm
->lbearing
== 0)
25917 it
->phys_ascent
= pcm
->ascent
+ boff
;
25918 it
->phys_descent
= pcm
->descent
- boff
;
25919 it
->pixel_width
= pcm
->width
;
25923 it
->glyph_not_available_p
= 1;
25924 it
->phys_ascent
= it
->ascent
;
25925 it
->phys_descent
= it
->descent
;
25926 it
->pixel_width
= font
->space_width
;
25929 if (it
->constrain_row_ascent_descent_p
)
25931 if (it
->descent
> it
->max_descent
)
25933 it
->ascent
+= it
->descent
- it
->max_descent
;
25934 it
->descent
= it
->max_descent
;
25936 if (it
->ascent
> it
->max_ascent
)
25938 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
25939 it
->ascent
= it
->max_ascent
;
25941 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
25942 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
25943 extra_line_spacing
= 0;
25946 /* If this is a space inside a region of text with
25947 `space-width' property, change its width. */
25948 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
25950 it
->pixel_width
*= XFLOATINT (it
->space_width
);
25952 /* If face has a box, add the box thickness to the character
25953 height. If character has a box line to the left and/or
25954 right, add the box line width to the character's width. */
25955 if (face
->box
!= FACE_NO_BOX
)
25957 int thick
= face
->box_line_width
;
25961 it
->ascent
+= thick
;
25962 it
->descent
+= thick
;
25967 if (it
->start_of_box_run_p
)
25968 it
->pixel_width
+= thick
;
25969 if (it
->end_of_box_run_p
)
25970 it
->pixel_width
+= thick
;
25973 /* If face has an overline, add the height of the overline
25974 (1 pixel) and a 1 pixel margin to the character height. */
25975 if (face
->overline_p
)
25976 it
->ascent
+= overline_margin
;
25978 if (it
->constrain_row_ascent_descent_p
)
25980 if (it
->ascent
> it
->max_ascent
)
25981 it
->ascent
= it
->max_ascent
;
25982 if (it
->descent
> it
->max_descent
)
25983 it
->descent
= it
->max_descent
;
25986 take_vertical_position_into_account (it
);
25988 /* If we have to actually produce glyphs, do it. */
25993 /* Translate a space with a `space-width' property
25994 into a stretch glyph. */
25995 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
25996 / FONT_HEIGHT (font
));
25997 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
25998 it
->ascent
+ it
->descent
, ascent
);
26003 /* If characters with lbearing or rbearing are displayed
26004 in this line, record that fact in a flag of the
26005 glyph row. This is used to optimize X output code. */
26006 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
26007 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
26009 if (! stretched_p
&& it
->pixel_width
== 0)
26010 /* We assure that all visible glyphs have at least 1-pixel
26012 it
->pixel_width
= 1;
26014 else if (it
->char_to_display
== '\n')
26016 /* A newline has no width, but we need the height of the
26017 line. But if previous part of the line sets a height,
26018 don't increase that height. */
26020 Lisp_Object height
;
26021 Lisp_Object total_height
= Qnil
;
26023 it
->override_ascent
= -1;
26024 it
->pixel_width
= 0;
26027 height
= get_it_property (it
, Qline_height
);
26028 /* Split (line-height total-height) list. */
26030 && CONSP (XCDR (height
))
26031 && NILP (XCDR (XCDR (height
))))
26033 total_height
= XCAR (XCDR (height
));
26034 height
= XCAR (height
);
26036 height
= calc_line_height_property (it
, height
, font
, boff
, 1);
26038 if (it
->override_ascent
>= 0)
26040 it
->ascent
= it
->override_ascent
;
26041 it
->descent
= it
->override_descent
;
26042 boff
= it
->override_boff
;
26046 it
->ascent
= FONT_BASE (font
) + boff
;
26047 it
->descent
= FONT_DESCENT (font
) - boff
;
26050 if (EQ (height
, Qt
))
26052 if (it
->descent
> it
->max_descent
)
26054 it
->ascent
+= it
->descent
- it
->max_descent
;
26055 it
->descent
= it
->max_descent
;
26057 if (it
->ascent
> it
->max_ascent
)
26059 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
26060 it
->ascent
= it
->max_ascent
;
26062 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
26063 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
26064 it
->constrain_row_ascent_descent_p
= 1;
26065 extra_line_spacing
= 0;
26069 Lisp_Object spacing
;
26071 it
->phys_ascent
= it
->ascent
;
26072 it
->phys_descent
= it
->descent
;
26074 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
26075 && face
->box
!= FACE_NO_BOX
26076 && face
->box_line_width
> 0)
26078 it
->ascent
+= face
->box_line_width
;
26079 it
->descent
+= face
->box_line_width
;
26082 && XINT (height
) > it
->ascent
+ it
->descent
)
26083 it
->ascent
= XINT (height
) - it
->descent
;
26085 if (!NILP (total_height
))
26086 spacing
= calc_line_height_property (it
, total_height
, font
, boff
, 0);
26089 spacing
= get_it_property (it
, Qline_spacing
);
26090 spacing
= calc_line_height_property (it
, spacing
, font
, boff
, 0);
26092 if (INTEGERP (spacing
))
26094 extra_line_spacing
= XINT (spacing
);
26095 if (!NILP (total_height
))
26096 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
26100 else /* i.e. (it->char_to_display == '\t') */
26102 if (font
->space_width
> 0)
26104 int tab_width
= it
->tab_width
* font
->space_width
;
26105 int x
= it
->current_x
+ it
->continuation_lines_width
;
26106 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
26108 /* If the distance from the current position to the next tab
26109 stop is less than a space character width, use the
26110 tab stop after that. */
26111 if (next_tab_x
- x
< font
->space_width
)
26112 next_tab_x
+= tab_width
;
26114 it
->pixel_width
= next_tab_x
- x
;
26116 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
26117 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
26121 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
26122 it
->ascent
+ it
->descent
, it
->ascent
);
26127 it
->pixel_width
= 0;
26132 else if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
< 0)
26134 /* A static composition.
26136 Note: A composition is represented as one glyph in the
26137 glyph matrix. There are no padding glyphs.
26139 Important note: pixel_width, ascent, and descent are the
26140 values of what is drawn by draw_glyphs (i.e. the values of
26141 the overall glyphs composed). */
26142 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
26143 int boff
; /* baseline offset */
26144 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
26145 int glyph_len
= cmp
->glyph_len
;
26146 struct font
*font
= face
->font
;
26150 /* If we have not yet calculated pixel size data of glyphs of
26151 the composition for the current face font, calculate them
26152 now. Theoretically, we have to check all fonts for the
26153 glyphs, but that requires much time and memory space. So,
26154 here we check only the font of the first glyph. This may
26155 lead to incorrect display, but it's very rare, and C-l
26156 (recenter-top-bottom) can correct the display anyway. */
26157 if (! cmp
->font
|| cmp
->font
!= font
)
26159 /* Ascent and descent of the font of the first character
26160 of this composition (adjusted by baseline offset).
26161 Ascent and descent of overall glyphs should not be less
26162 than these, respectively. */
26163 int font_ascent
, font_descent
, font_height
;
26164 /* Bounding box of the overall glyphs. */
26165 int leftmost
, rightmost
, lowest
, highest
;
26166 int lbearing
, rbearing
;
26167 int i
, width
, ascent
, descent
;
26168 int left_padded
= 0, right_padded
= 0;
26169 int c
IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
26171 struct font_metrics
*pcm
;
26172 int font_not_found_p
;
26175 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
26176 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
26178 if (glyph_len
< cmp
->glyph_len
)
26180 for (i
= 0; i
< glyph_len
; i
++)
26182 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
26184 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
26189 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
26190 : IT_CHARPOS (*it
));
26191 /* If no suitable font is found, use the default font. */
26192 font_not_found_p
= font
== NULL
;
26193 if (font_not_found_p
)
26195 face
= face
->ascii_face
;
26198 boff
= font
->baseline_offset
;
26199 if (font
->vertical_centering
)
26200 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
26201 font_ascent
= FONT_BASE (font
) + boff
;
26202 font_descent
= FONT_DESCENT (font
) - boff
;
26203 font_height
= FONT_HEIGHT (font
);
26208 if (! font_not_found_p
)
26210 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
26212 pcm
= get_per_char_metric (font
, &char2b
);
26215 /* Initialize the bounding box. */
26218 width
= cmp
->glyph_len
> 0 ? pcm
->width
: 0;
26219 ascent
= pcm
->ascent
;
26220 descent
= pcm
->descent
;
26221 lbearing
= pcm
->lbearing
;
26222 rbearing
= pcm
->rbearing
;
26226 width
= cmp
->glyph_len
> 0 ? font
->space_width
: 0;
26227 ascent
= FONT_BASE (font
);
26228 descent
= FONT_DESCENT (font
);
26235 lowest
= - descent
+ boff
;
26236 highest
= ascent
+ boff
;
26238 if (! font_not_found_p
26239 && font
->default_ascent
26240 && CHAR_TABLE_P (Vuse_default_ascent
)
26241 && !NILP (Faref (Vuse_default_ascent
,
26242 make_number (it
->char_to_display
))))
26243 highest
= font
->default_ascent
+ boff
;
26245 /* Draw the first glyph at the normal position. It may be
26246 shifted to right later if some other glyphs are drawn
26248 cmp
->offsets
[i
* 2] = 0;
26249 cmp
->offsets
[i
* 2 + 1] = boff
;
26250 cmp
->lbearing
= lbearing
;
26251 cmp
->rbearing
= rbearing
;
26253 /* Set cmp->offsets for the remaining glyphs. */
26254 for (i
++; i
< glyph_len
; i
++)
26256 int left
, right
, btm
, top
;
26257 int ch
= COMPOSITION_GLYPH (cmp
, i
);
26259 struct face
*this_face
;
26263 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
26264 this_face
= FACE_FROM_ID (it
->f
, face_id
);
26265 font
= this_face
->font
;
26271 get_char_face_and_encoding (it
->f
, ch
, face_id
,
26273 pcm
= get_per_char_metric (font
, &char2b
);
26276 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
26279 width
= pcm
->width
;
26280 ascent
= pcm
->ascent
;
26281 descent
= pcm
->descent
;
26282 lbearing
= pcm
->lbearing
;
26283 rbearing
= pcm
->rbearing
;
26284 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
26286 /* Relative composition with or without
26287 alternate chars. */
26288 left
= (leftmost
+ rightmost
- width
) / 2;
26289 btm
= - descent
+ boff
;
26290 if (font
->relative_compose
26291 && (! CHAR_TABLE_P (Vignore_relative_composition
)
26292 || NILP (Faref (Vignore_relative_composition
,
26293 make_number (ch
)))))
26296 if (- descent
>= font
->relative_compose
)
26297 /* One extra pixel between two glyphs. */
26299 else if (ascent
<= 0)
26300 /* One extra pixel between two glyphs. */
26301 btm
= lowest
- 1 - ascent
- descent
;
26306 /* A composition rule is specified by an integer
26307 value that encodes global and new reference
26308 points (GREF and NREF). GREF and NREF are
26309 specified by numbers as below:
26311 0---1---2 -- ascent
26315 9--10--11 -- center
26317 ---3---4---5--- baseline
26319 6---7---8 -- descent
26321 int rule
= COMPOSITION_RULE (cmp
, i
);
26322 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
26324 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
26325 grefx
= gref
% 3, nrefx
= nref
% 3;
26326 grefy
= gref
/ 3, nrefy
= nref
/ 3;
26328 xoff
= font_height
* (xoff
- 128) / 256;
26330 yoff
= font_height
* (yoff
- 128) / 256;
26333 + grefx
* (rightmost
- leftmost
) / 2
26334 - nrefx
* width
/ 2
26337 btm
= ((grefy
== 0 ? highest
26339 : grefy
== 2 ? lowest
26340 : (highest
+ lowest
) / 2)
26341 - (nrefy
== 0 ? ascent
+ descent
26342 : nrefy
== 1 ? descent
- boff
26344 : (ascent
+ descent
) / 2)
26348 cmp
->offsets
[i
* 2] = left
;
26349 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
26351 /* Update the bounding box of the overall glyphs. */
26354 right
= left
+ width
;
26355 if (left
< leftmost
)
26357 if (right
> rightmost
)
26360 top
= btm
+ descent
+ ascent
;
26366 if (cmp
->lbearing
> left
+ lbearing
)
26367 cmp
->lbearing
= left
+ lbearing
;
26368 if (cmp
->rbearing
< left
+ rbearing
)
26369 cmp
->rbearing
= left
+ rbearing
;
26373 /* If there are glyphs whose x-offsets are negative,
26374 shift all glyphs to the right and make all x-offsets
26378 for (i
= 0; i
< cmp
->glyph_len
; i
++)
26379 cmp
->offsets
[i
* 2] -= leftmost
;
26380 rightmost
-= leftmost
;
26381 cmp
->lbearing
-= leftmost
;
26382 cmp
->rbearing
-= leftmost
;
26385 if (left_padded
&& cmp
->lbearing
< 0)
26387 for (i
= 0; i
< cmp
->glyph_len
; i
++)
26388 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
26389 rightmost
-= cmp
->lbearing
;
26390 cmp
->rbearing
-= cmp
->lbearing
;
26393 if (right_padded
&& rightmost
< cmp
->rbearing
)
26395 rightmost
= cmp
->rbearing
;
26398 cmp
->pixel_width
= rightmost
;
26399 cmp
->ascent
= highest
;
26400 cmp
->descent
= - lowest
;
26401 if (cmp
->ascent
< font_ascent
)
26402 cmp
->ascent
= font_ascent
;
26403 if (cmp
->descent
< font_descent
)
26404 cmp
->descent
= font_descent
;
26408 && (cmp
->lbearing
< 0
26409 || cmp
->rbearing
> cmp
->pixel_width
))
26410 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
26412 it
->pixel_width
= cmp
->pixel_width
;
26413 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
26414 it
->descent
= it
->phys_descent
= cmp
->descent
;
26415 if (face
->box
!= FACE_NO_BOX
)
26417 int thick
= face
->box_line_width
;
26421 it
->ascent
+= thick
;
26422 it
->descent
+= thick
;
26427 if (it
->start_of_box_run_p
)
26428 it
->pixel_width
+= thick
;
26429 if (it
->end_of_box_run_p
)
26430 it
->pixel_width
+= thick
;
26433 /* If face has an overline, add the height of the overline
26434 (1 pixel) and a 1 pixel margin to the character height. */
26435 if (face
->overline_p
)
26436 it
->ascent
+= overline_margin
;
26438 take_vertical_position_into_account (it
);
26439 if (it
->ascent
< 0)
26441 if (it
->descent
< 0)
26444 if (it
->glyph_row
&& cmp
->glyph_len
> 0)
26445 append_composite_glyph (it
);
26447 else if (it
->what
== IT_COMPOSITION
)
26449 /* A dynamic (automatic) composition. */
26450 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
26451 Lisp_Object gstring
;
26452 struct font_metrics metrics
;
26456 gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
26458 = composition_gstring_width (gstring
, it
->cmp_it
.from
, it
->cmp_it
.to
,
26461 && (metrics
.lbearing
< 0 || metrics
.rbearing
> metrics
.width
))
26462 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
26463 it
->ascent
= it
->phys_ascent
= metrics
.ascent
;
26464 it
->descent
= it
->phys_descent
= metrics
.descent
;
26465 if (face
->box
!= FACE_NO_BOX
)
26467 int thick
= face
->box_line_width
;
26471 it
->ascent
+= thick
;
26472 it
->descent
+= thick
;
26477 if (it
->start_of_box_run_p
)
26478 it
->pixel_width
+= thick
;
26479 if (it
->end_of_box_run_p
)
26480 it
->pixel_width
+= thick
;
26482 /* If face has an overline, add the height of the overline
26483 (1 pixel) and a 1 pixel margin to the character height. */
26484 if (face
->overline_p
)
26485 it
->ascent
+= overline_margin
;
26486 take_vertical_position_into_account (it
);
26487 if (it
->ascent
< 0)
26489 if (it
->descent
< 0)
26493 append_composite_glyph (it
);
26495 else if (it
->what
== IT_GLYPHLESS
)
26496 produce_glyphless_glyph (it
, 0, Qnil
);
26497 else if (it
->what
== IT_IMAGE
)
26498 produce_image_glyph (it
);
26499 else if (it
->what
== IT_STRETCH
)
26500 produce_stretch_glyph (it
);
26503 /* Accumulate dimensions. Note: can't assume that it->descent > 0
26504 because this isn't true for images with `:ascent 100'. */
26505 eassert (it
->ascent
>= 0 && it
->descent
>= 0);
26506 if (it
->area
== TEXT_AREA
)
26507 it
->current_x
+= it
->pixel_width
;
26509 if (extra_line_spacing
> 0)
26511 it
->descent
+= extra_line_spacing
;
26512 if (extra_line_spacing
> it
->max_extra_line_spacing
)
26513 it
->max_extra_line_spacing
= extra_line_spacing
;
26516 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
26517 it
->max_descent
= max (it
->max_descent
, it
->descent
);
26518 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
26519 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
26523 Output LEN glyphs starting at START at the nominal cursor position.
26524 Advance the nominal cursor over the text. UPDATED_ROW is the glyph row
26525 being updated, and UPDATED_AREA is the area of that row being updated. */
26528 x_write_glyphs (struct window
*w
, struct glyph_row
*updated_row
,
26529 struct glyph
*start
, enum glyph_row_area updated_area
, int len
)
26531 int x
, hpos
, chpos
= w
->phys_cursor
.hpos
;
26533 eassert (updated_row
);
26534 /* When the window is hscrolled, cursor hpos can legitimately be out
26535 of bounds, but we draw the cursor at the corresponding window
26536 margin in that case. */
26537 if (!updated_row
->reversed_p
&& chpos
< 0)
26539 if (updated_row
->reversed_p
&& chpos
>= updated_row
->used
[TEXT_AREA
])
26540 chpos
= updated_row
->used
[TEXT_AREA
] - 1;
26544 /* Write glyphs. */
26546 hpos
= start
- updated_row
->glyphs
[updated_area
];
26547 x
= draw_glyphs (w
, w
->output_cursor
.x
,
26548 updated_row
, updated_area
,
26550 DRAW_NORMAL_TEXT
, 0);
26552 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
26553 if (updated_area
== TEXT_AREA
26554 && w
->phys_cursor_on_p
26555 && w
->phys_cursor
.vpos
== w
->output_cursor
.vpos
26557 && chpos
< hpos
+ len
)
26558 w
->phys_cursor_on_p
= 0;
26562 /* Advance the output cursor. */
26563 w
->output_cursor
.hpos
+= len
;
26564 w
->output_cursor
.x
= x
;
26569 Insert LEN glyphs from START at the nominal cursor position. */
26572 x_insert_glyphs (struct window
*w
, struct glyph_row
*updated_row
,
26573 struct glyph
*start
, enum glyph_row_area updated_area
, int len
)
26576 int line_height
, shift_by_width
, shifted_region_width
;
26577 struct glyph_row
*row
;
26578 struct glyph
*glyph
;
26579 int frame_x
, frame_y
;
26582 eassert (updated_row
);
26584 f
= XFRAME (WINDOW_FRAME (w
));
26586 /* Get the height of the line we are in. */
26588 line_height
= row
->height
;
26590 /* Get the width of the glyphs to insert. */
26591 shift_by_width
= 0;
26592 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
26593 shift_by_width
+= glyph
->pixel_width
;
26595 /* Get the width of the region to shift right. */
26596 shifted_region_width
= (window_box_width (w
, updated_area
)
26597 - w
->output_cursor
.x
26601 frame_x
= window_box_left (w
, updated_area
) + w
->output_cursor
.x
;
26602 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, w
->output_cursor
.y
);
26604 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
26605 line_height
, shift_by_width
);
26607 /* Write the glyphs. */
26608 hpos
= start
- row
->glyphs
[updated_area
];
26609 draw_glyphs (w
, w
->output_cursor
.x
, row
, updated_area
,
26611 DRAW_NORMAL_TEXT
, 0);
26613 /* Advance the output cursor. */
26614 w
->output_cursor
.hpos
+= len
;
26615 w
->output_cursor
.x
+= shift_by_width
;
26621 Erase the current text line from the nominal cursor position
26622 (inclusive) to pixel column TO_X (exclusive). The idea is that
26623 everything from TO_X onward is already erased.
26625 TO_X is a pixel position relative to UPDATED_AREA of currently
26626 updated window W. TO_X == -1 means clear to the end of this area. */
26629 x_clear_end_of_line (struct window
*w
, struct glyph_row
*updated_row
,
26630 enum glyph_row_area updated_area
, int to_x
)
26633 int max_x
, min_y
, max_y
;
26634 int from_x
, from_y
, to_y
;
26636 eassert (updated_row
);
26637 f
= XFRAME (w
->frame
);
26639 if (updated_row
->full_width_p
)
26640 max_x
= (WINDOW_PIXEL_WIDTH (w
)
26641 - (updated_row
->mode_line_p
? WINDOW_RIGHT_DIVIDER_WIDTH (w
) : 0));
26643 max_x
= window_box_width (w
, updated_area
);
26644 max_y
= window_text_bottom_y (w
);
26646 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
26647 of window. For TO_X > 0, truncate to end of drawing area. */
26653 to_x
= min (to_x
, max_x
);
26655 to_y
= min (max_y
, w
->output_cursor
.y
+ updated_row
->height
);
26657 /* Notice if the cursor will be cleared by this operation. */
26658 if (!updated_row
->full_width_p
)
26659 notice_overwritten_cursor (w
, updated_area
,
26660 w
->output_cursor
.x
, -1,
26662 MATRIX_ROW_BOTTOM_Y (updated_row
));
26664 from_x
= w
->output_cursor
.x
;
26666 /* Translate to frame coordinates. */
26667 if (updated_row
->full_width_p
)
26669 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
26670 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
26674 int area_left
= window_box_left (w
, updated_area
);
26675 from_x
+= area_left
;
26679 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
26680 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, w
->output_cursor
.y
));
26681 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
26683 /* Prevent inadvertently clearing to end of the X window. */
26684 if (to_x
> from_x
&& to_y
> from_y
)
26687 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
26688 to_x
- from_x
, to_y
- from_y
);
26693 #endif /* HAVE_WINDOW_SYSTEM */
26697 /***********************************************************************
26699 ***********************************************************************/
26701 /* Value is the internal representation of the specified cursor type
26702 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
26703 of the bar cursor. */
26705 static enum text_cursor_kinds
26706 get_specified_cursor_type (Lisp_Object arg
, int *width
)
26708 enum text_cursor_kinds type
;
26713 if (EQ (arg
, Qbox
))
26714 return FILLED_BOX_CURSOR
;
26716 if (EQ (arg
, Qhollow
))
26717 return HOLLOW_BOX_CURSOR
;
26719 if (EQ (arg
, Qbar
))
26726 && EQ (XCAR (arg
), Qbar
)
26727 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
26729 *width
= XINT (XCDR (arg
));
26733 if (EQ (arg
, Qhbar
))
26736 return HBAR_CURSOR
;
26740 && EQ (XCAR (arg
), Qhbar
)
26741 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
26743 *width
= XINT (XCDR (arg
));
26744 return HBAR_CURSOR
;
26747 /* Treat anything unknown as "hollow box cursor".
26748 It was bad to signal an error; people have trouble fixing
26749 .Xdefaults with Emacs, when it has something bad in it. */
26750 type
= HOLLOW_BOX_CURSOR
;
26755 /* Set the default cursor types for specified frame. */
26757 set_frame_cursor_types (struct frame
*f
, Lisp_Object arg
)
26762 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
26763 FRAME_CURSOR_WIDTH (f
) = width
;
26765 /* By default, set up the blink-off state depending on the on-state. */
26767 tem
= Fassoc (arg
, Vblink_cursor_alist
);
26770 FRAME_BLINK_OFF_CURSOR (f
)
26771 = get_specified_cursor_type (XCDR (tem
), &width
);
26772 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
26775 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
26777 /* Make sure the cursor gets redrawn. */
26778 f
->cursor_type_changed
= 1;
26782 #ifdef HAVE_WINDOW_SYSTEM
26784 /* Return the cursor we want to be displayed in window W. Return
26785 width of bar/hbar cursor through WIDTH arg. Return with
26786 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
26787 (i.e. if the `system caret' should track this cursor).
26789 In a mini-buffer window, we want the cursor only to appear if we
26790 are reading input from this window. For the selected window, we
26791 want the cursor type given by the frame parameter or buffer local
26792 setting of cursor-type. If explicitly marked off, draw no cursor.
26793 In all other cases, we want a hollow box cursor. */
26795 static enum text_cursor_kinds
26796 get_window_cursor_type (struct window
*w
, struct glyph
*glyph
, int *width
,
26797 int *active_cursor
)
26799 struct frame
*f
= XFRAME (w
->frame
);
26800 struct buffer
*b
= XBUFFER (w
->contents
);
26801 int cursor_type
= DEFAULT_CURSOR
;
26802 Lisp_Object alt_cursor
;
26803 int non_selected
= 0;
26805 *active_cursor
= 1;
26808 if (cursor_in_echo_area
26809 && FRAME_HAS_MINIBUF_P (f
)
26810 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
26812 if (w
== XWINDOW (echo_area_window
))
26814 if (EQ (BVAR (b
, cursor_type
), Qt
) || NILP (BVAR (b
, cursor_type
)))
26816 *width
= FRAME_CURSOR_WIDTH (f
);
26817 return FRAME_DESIRED_CURSOR (f
);
26820 return get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
26823 *active_cursor
= 0;
26827 /* Detect a nonselected window or nonselected frame. */
26828 else if (w
!= XWINDOW (f
->selected_window
)
26829 || f
!= FRAME_DISPLAY_INFO (f
)->x_highlight_frame
)
26831 *active_cursor
= 0;
26833 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
26839 /* Never display a cursor in a window in which cursor-type is nil. */
26840 if (NILP (BVAR (b
, cursor_type
)))
26843 /* Get the normal cursor type for this window. */
26844 if (EQ (BVAR (b
, cursor_type
), Qt
))
26846 cursor_type
= FRAME_DESIRED_CURSOR (f
);
26847 *width
= FRAME_CURSOR_WIDTH (f
);
26850 cursor_type
= get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
26852 /* Use cursor-in-non-selected-windows instead
26853 for non-selected window or frame. */
26856 alt_cursor
= BVAR (b
, cursor_in_non_selected_windows
);
26857 if (!EQ (Qt
, alt_cursor
))
26858 return get_specified_cursor_type (alt_cursor
, width
);
26859 /* t means modify the normal cursor type. */
26860 if (cursor_type
== FILLED_BOX_CURSOR
)
26861 cursor_type
= HOLLOW_BOX_CURSOR
;
26862 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
26864 return cursor_type
;
26867 /* Use normal cursor if not blinked off. */
26868 if (!w
->cursor_off_p
)
26870 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
26872 if (cursor_type
== FILLED_BOX_CURSOR
)
26874 /* Using a block cursor on large images can be very annoying.
26875 So use a hollow cursor for "large" images.
26876 If image is not transparent (no mask), also use hollow cursor. */
26877 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
26878 if (img
!= NULL
&& IMAGEP (img
->spec
))
26880 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
26881 where N = size of default frame font size.
26882 This should cover most of the "tiny" icons people may use. */
26884 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
26885 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
26886 cursor_type
= HOLLOW_BOX_CURSOR
;
26889 else if (cursor_type
!= NO_CURSOR
)
26891 /* Display current only supports BOX and HOLLOW cursors for images.
26892 So for now, unconditionally use a HOLLOW cursor when cursor is
26893 not a solid box cursor. */
26894 cursor_type
= HOLLOW_BOX_CURSOR
;
26897 return cursor_type
;
26900 /* Cursor is blinked off, so determine how to "toggle" it. */
26902 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
26903 if ((alt_cursor
= Fassoc (BVAR (b
, cursor_type
), Vblink_cursor_alist
), !NILP (alt_cursor
)))
26904 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
26906 /* Then see if frame has specified a specific blink off cursor type. */
26907 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
26909 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
26910 return FRAME_BLINK_OFF_CURSOR (f
);
26914 /* Some people liked having a permanently visible blinking cursor,
26915 while others had very strong opinions against it. So it was
26916 decided to remove it. KFS 2003-09-03 */
26918 /* Finally perform built-in cursor blinking:
26919 filled box <-> hollow box
26920 wide [h]bar <-> narrow [h]bar
26921 narrow [h]bar <-> no cursor
26922 other type <-> no cursor */
26924 if (cursor_type
== FILLED_BOX_CURSOR
)
26925 return HOLLOW_BOX_CURSOR
;
26927 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
26930 return cursor_type
;
26938 /* Notice when the text cursor of window W has been completely
26939 overwritten by a drawing operation that outputs glyphs in AREA
26940 starting at X0 and ending at X1 in the line starting at Y0 and
26941 ending at Y1. X coordinates are area-relative. X1 < 0 means all
26942 the rest of the line after X0 has been written. Y coordinates
26943 are window-relative. */
26946 notice_overwritten_cursor (struct window
*w
, enum glyph_row_area area
,
26947 int x0
, int x1
, int y0
, int y1
)
26949 int cx0
, cx1
, cy0
, cy1
;
26950 struct glyph_row
*row
;
26952 if (!w
->phys_cursor_on_p
)
26954 if (area
!= TEXT_AREA
)
26957 if (w
->phys_cursor
.vpos
< 0
26958 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
26959 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
26960 !(row
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
))))
26963 if (row
->cursor_in_fringe_p
)
26965 row
->cursor_in_fringe_p
= 0;
26966 draw_fringe_bitmap (w
, row
, row
->reversed_p
);
26967 w
->phys_cursor_on_p
= 0;
26971 cx0
= w
->phys_cursor
.x
;
26972 cx1
= cx0
+ w
->phys_cursor_width
;
26973 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
26976 /* The cursor image will be completely removed from the
26977 screen if the output area intersects the cursor area in
26978 y-direction. When we draw in [y0 y1[, and some part of
26979 the cursor is at y < y0, that part must have been drawn
26980 before. When scrolling, the cursor is erased before
26981 actually scrolling, so we don't come here. When not
26982 scrolling, the rows above the old cursor row must have
26983 changed, and in this case these rows must have written
26984 over the cursor image.
26986 Likewise if part of the cursor is below y1, with the
26987 exception of the cursor being in the first blank row at
26988 the buffer and window end because update_text_area
26989 doesn't draw that row. (Except when it does, but
26990 that's handled in update_text_area.) */
26992 cy0
= w
->phys_cursor
.y
;
26993 cy1
= cy0
+ w
->phys_cursor_height
;
26994 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
26997 w
->phys_cursor_on_p
= 0;
27000 #endif /* HAVE_WINDOW_SYSTEM */
27003 /************************************************************************
27005 ************************************************************************/
27007 #ifdef HAVE_WINDOW_SYSTEM
27010 Fix the display of area AREA of overlapping row ROW in window W
27011 with respect to the overlapping part OVERLAPS. */
27014 x_fix_overlapping_area (struct window
*w
, struct glyph_row
*row
,
27015 enum glyph_row_area area
, int overlaps
)
27022 for (i
= 0; i
< row
->used
[area
];)
27024 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
27026 int start
= i
, start_x
= x
;
27030 x
+= row
->glyphs
[area
][i
].pixel_width
;
27033 while (i
< row
->used
[area
]
27034 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
27036 draw_glyphs (w
, start_x
, row
, area
,
27038 DRAW_NORMAL_TEXT
, overlaps
);
27042 x
+= row
->glyphs
[area
][i
].pixel_width
;
27052 Draw the cursor glyph of window W in glyph row ROW. See the
27053 comment of draw_glyphs for the meaning of HL. */
27056 draw_phys_cursor_glyph (struct window
*w
, struct glyph_row
*row
,
27057 enum draw_glyphs_face hl
)
27059 /* If cursor hpos is out of bounds, don't draw garbage. This can
27060 happen in mini-buffer windows when switching between echo area
27061 glyphs and mini-buffer. */
27062 if ((row
->reversed_p
27063 ? (w
->phys_cursor
.hpos
>= 0)
27064 : (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])))
27066 int on_p
= w
->phys_cursor_on_p
;
27068 int hpos
= w
->phys_cursor
.hpos
;
27070 /* When the window is hscrolled, cursor hpos can legitimately be
27071 out of bounds, but we draw the cursor at the corresponding
27072 window margin in that case. */
27073 if (!row
->reversed_p
&& hpos
< 0)
27075 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
27076 hpos
= row
->used
[TEXT_AREA
] - 1;
27078 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
, hpos
, hpos
+ 1,
27080 w
->phys_cursor_on_p
= on_p
;
27082 if (hl
== DRAW_CURSOR
)
27083 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
27084 /* When we erase the cursor, and ROW is overlapped by other
27085 rows, make sure that these overlapping parts of other rows
27087 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
27089 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
27091 if (row
> w
->current_matrix
->rows
27092 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
27093 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
27094 OVERLAPS_ERASED_CURSOR
);
27096 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
27097 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
27098 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
27099 OVERLAPS_ERASED_CURSOR
);
27105 /* Erase the image of a cursor of window W from the screen. */
27108 erase_phys_cursor (struct window
*w
)
27110 struct frame
*f
= XFRAME (w
->frame
);
27111 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27112 int hpos
= w
->phys_cursor
.hpos
;
27113 int vpos
= w
->phys_cursor
.vpos
;
27114 int mouse_face_here_p
= 0;
27115 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
27116 struct glyph_row
*cursor_row
;
27117 struct glyph
*cursor_glyph
;
27118 enum draw_glyphs_face hl
;
27120 /* No cursor displayed or row invalidated => nothing to do on the
27122 if (w
->phys_cursor_type
== NO_CURSOR
)
27123 goto mark_cursor_off
;
27125 /* VPOS >= active_glyphs->nrows means that window has been resized.
27126 Don't bother to erase the cursor. */
27127 if (vpos
>= active_glyphs
->nrows
)
27128 goto mark_cursor_off
;
27130 /* If row containing cursor is marked invalid, there is nothing we
27132 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
27133 if (!cursor_row
->enabled_p
)
27134 goto mark_cursor_off
;
27136 /* If line spacing is > 0, old cursor may only be partially visible in
27137 window after split-window. So adjust visible height. */
27138 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
27139 window_text_bottom_y (w
) - cursor_row
->y
);
27141 /* If row is completely invisible, don't attempt to delete a cursor which
27142 isn't there. This can happen if cursor is at top of a window, and
27143 we switch to a buffer with a header line in that window. */
27144 if (cursor_row
->visible_height
<= 0)
27145 goto mark_cursor_off
;
27147 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
27148 if (cursor_row
->cursor_in_fringe_p
)
27150 cursor_row
->cursor_in_fringe_p
= 0;
27151 draw_fringe_bitmap (w
, cursor_row
, cursor_row
->reversed_p
);
27152 goto mark_cursor_off
;
27155 /* This can happen when the new row is shorter than the old one.
27156 In this case, either draw_glyphs or clear_end_of_line
27157 should have cleared the cursor. Note that we wouldn't be
27158 able to erase the cursor in this case because we don't have a
27159 cursor glyph at hand. */
27160 if ((cursor_row
->reversed_p
27161 ? (w
->phys_cursor
.hpos
< 0)
27162 : (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])))
27163 goto mark_cursor_off
;
27165 /* When the window is hscrolled, cursor hpos can legitimately be out
27166 of bounds, but we draw the cursor at the corresponding window
27167 margin in that case. */
27168 if (!cursor_row
->reversed_p
&& hpos
< 0)
27170 if (cursor_row
->reversed_p
&& hpos
>= cursor_row
->used
[TEXT_AREA
])
27171 hpos
= cursor_row
->used
[TEXT_AREA
] - 1;
27173 /* If the cursor is in the mouse face area, redisplay that when
27174 we clear the cursor. */
27175 if (! NILP (hlinfo
->mouse_face_window
)
27176 && coords_in_mouse_face_p (w
, hpos
, vpos
)
27177 /* Don't redraw the cursor's spot in mouse face if it is at the
27178 end of a line (on a newline). The cursor appears there, but
27179 mouse highlighting does not. */
27180 && cursor_row
->used
[TEXT_AREA
] > hpos
&& hpos
>= 0)
27181 mouse_face_here_p
= 1;
27183 /* Maybe clear the display under the cursor. */
27184 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
27187 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
27190 cursor_glyph
= get_phys_cursor_glyph (w
);
27191 if (cursor_glyph
== NULL
)
27192 goto mark_cursor_off
;
27194 width
= cursor_glyph
->pixel_width
;
27195 left_x
= window_box_left_offset (w
, TEXT_AREA
);
27196 x
= w
->phys_cursor
.x
;
27198 width
-= left_x
- x
;
27199 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
27200 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
27201 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
27204 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
27207 /* Erase the cursor by redrawing the character underneath it. */
27208 if (mouse_face_here_p
)
27209 hl
= DRAW_MOUSE_FACE
;
27211 hl
= DRAW_NORMAL_TEXT
;
27212 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
27215 w
->phys_cursor_on_p
= 0;
27216 w
->phys_cursor_type
= NO_CURSOR
;
27221 Display or clear cursor of window W. If ON is zero, clear the
27222 cursor. If it is non-zero, display the cursor. If ON is nonzero,
27223 where to put the cursor is specified by HPOS, VPOS, X and Y. */
27226 display_and_set_cursor (struct window
*w
, bool on
,
27227 int hpos
, int vpos
, int x
, int y
)
27229 struct frame
*f
= XFRAME (w
->frame
);
27230 int new_cursor_type
;
27231 int new_cursor_width
;
27233 struct glyph_row
*glyph_row
;
27234 struct glyph
*glyph
;
27236 /* This is pointless on invisible frames, and dangerous on garbaged
27237 windows and frames; in the latter case, the frame or window may
27238 be in the midst of changing its size, and x and y may be off the
27240 if (! FRAME_VISIBLE_P (f
)
27241 || FRAME_GARBAGED_P (f
)
27242 || vpos
>= w
->current_matrix
->nrows
27243 || hpos
>= w
->current_matrix
->matrix_w
)
27246 /* If cursor is off and we want it off, return quickly. */
27247 if (!on
&& !w
->phys_cursor_on_p
)
27250 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
27251 /* If cursor row is not enabled, we don't really know where to
27252 display the cursor. */
27253 if (!glyph_row
->enabled_p
)
27255 w
->phys_cursor_on_p
= 0;
27260 if (!glyph_row
->exact_window_width_line_p
27261 || (0 <= hpos
&& hpos
< glyph_row
->used
[TEXT_AREA
]))
27262 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
27264 eassert (input_blocked_p ());
27266 /* Set new_cursor_type to the cursor we want to be displayed. */
27267 new_cursor_type
= get_window_cursor_type (w
, glyph
,
27268 &new_cursor_width
, &active_cursor
);
27270 /* If cursor is currently being shown and we don't want it to be or
27271 it is in the wrong place, or the cursor type is not what we want,
27273 if (w
->phys_cursor_on_p
27275 || w
->phys_cursor
.x
!= x
27276 || w
->phys_cursor
.y
!= y
27277 || new_cursor_type
!= w
->phys_cursor_type
27278 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
27279 && new_cursor_width
!= w
->phys_cursor_width
)))
27280 erase_phys_cursor (w
);
27282 /* Don't check phys_cursor_on_p here because that flag is only set
27283 to zero in some cases where we know that the cursor has been
27284 completely erased, to avoid the extra work of erasing the cursor
27285 twice. In other words, phys_cursor_on_p can be 1 and the cursor
27286 still not be visible, or it has only been partly erased. */
27289 w
->phys_cursor_ascent
= glyph_row
->ascent
;
27290 w
->phys_cursor_height
= glyph_row
->height
;
27292 /* Set phys_cursor_.* before x_draw_.* is called because some
27293 of them may need the information. */
27294 w
->phys_cursor
.x
= x
;
27295 w
->phys_cursor
.y
= glyph_row
->y
;
27296 w
->phys_cursor
.hpos
= hpos
;
27297 w
->phys_cursor
.vpos
= vpos
;
27300 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
27301 new_cursor_type
, new_cursor_width
,
27302 on
, active_cursor
);
27306 /* Switch the display of W's cursor on or off, according to the value
27310 update_window_cursor (struct window
*w
, bool on
)
27312 /* Don't update cursor in windows whose frame is in the process
27313 of being deleted. */
27314 if (w
->current_matrix
)
27316 int hpos
= w
->phys_cursor
.hpos
;
27317 int vpos
= w
->phys_cursor
.vpos
;
27318 struct glyph_row
*row
;
27320 if (vpos
>= w
->current_matrix
->nrows
27321 || hpos
>= w
->current_matrix
->matrix_w
)
27324 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
27326 /* When the window is hscrolled, cursor hpos can legitimately be
27327 out of bounds, but we draw the cursor at the corresponding
27328 window margin in that case. */
27329 if (!row
->reversed_p
&& hpos
< 0)
27331 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
27332 hpos
= row
->used
[TEXT_AREA
] - 1;
27335 display_and_set_cursor (w
, on
, hpos
, vpos
,
27336 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
27342 /* Call update_window_cursor with parameter ON_P on all leaf windows
27343 in the window tree rooted at W. */
27346 update_cursor_in_window_tree (struct window
*w
, bool on_p
)
27350 if (WINDOWP (w
->contents
))
27351 update_cursor_in_window_tree (XWINDOW (w
->contents
), on_p
);
27353 update_window_cursor (w
, on_p
);
27355 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
27361 Display the cursor on window W, or clear it, according to ON_P.
27362 Don't change the cursor's position. */
27365 x_update_cursor (struct frame
*f
, bool on_p
)
27367 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
27372 Clear the cursor of window W to background color, and mark the
27373 cursor as not shown. This is used when the text where the cursor
27374 is about to be rewritten. */
27377 x_clear_cursor (struct window
*w
)
27379 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
27380 update_window_cursor (w
, 0);
27383 #endif /* HAVE_WINDOW_SYSTEM */
27385 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
27388 draw_row_with_mouse_face (struct window
*w
, int start_x
, struct glyph_row
*row
,
27389 int start_hpos
, int end_hpos
,
27390 enum draw_glyphs_face draw
)
27392 #ifdef HAVE_WINDOW_SYSTEM
27393 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
27395 draw_glyphs (w
, start_x
, row
, TEXT_AREA
, start_hpos
, end_hpos
, draw
, 0);
27399 #if defined (HAVE_GPM) || defined (MSDOS) || defined (WINDOWSNT)
27400 tty_draw_row_with_mouse_face (w
, row
, start_hpos
, end_hpos
, draw
);
27404 /* Display the active region described by mouse_face_* according to DRAW. */
27407 show_mouse_face (Mouse_HLInfo
*hlinfo
, enum draw_glyphs_face draw
)
27409 struct window
*w
= XWINDOW (hlinfo
->mouse_face_window
);
27410 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
27412 if (/* If window is in the process of being destroyed, don't bother
27414 w
->current_matrix
!= NULL
27415 /* Don't update mouse highlight if hidden. */
27416 && (draw
!= DRAW_MOUSE_FACE
|| !hlinfo
->mouse_face_hidden
)
27417 /* Recognize when we are called to operate on rows that don't exist
27418 anymore. This can happen when a window is split. */
27419 && hlinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
27421 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
27422 struct glyph_row
*row
, *first
, *last
;
27424 first
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
27425 last
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
27427 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
27429 int start_hpos
, end_hpos
, start_x
;
27431 /* For all but the first row, the highlight starts at column 0. */
27434 /* R2L rows have BEG and END in reversed order, but the
27435 screen drawing geometry is always left to right. So
27436 we need to mirror the beginning and end of the
27437 highlighted area in R2L rows. */
27438 if (!row
->reversed_p
)
27440 start_hpos
= hlinfo
->mouse_face_beg_col
;
27441 start_x
= hlinfo
->mouse_face_beg_x
;
27443 else if (row
== last
)
27445 start_hpos
= hlinfo
->mouse_face_end_col
;
27446 start_x
= hlinfo
->mouse_face_end_x
;
27454 else if (row
->reversed_p
&& row
== last
)
27456 start_hpos
= hlinfo
->mouse_face_end_col
;
27457 start_x
= hlinfo
->mouse_face_end_x
;
27467 if (!row
->reversed_p
)
27468 end_hpos
= hlinfo
->mouse_face_end_col
;
27469 else if (row
== first
)
27470 end_hpos
= hlinfo
->mouse_face_beg_col
;
27473 end_hpos
= row
->used
[TEXT_AREA
];
27474 if (draw
== DRAW_NORMAL_TEXT
)
27475 row
->fill_line_p
= 1; /* Clear to end of line */
27478 else if (row
->reversed_p
&& row
== first
)
27479 end_hpos
= hlinfo
->mouse_face_beg_col
;
27482 end_hpos
= row
->used
[TEXT_AREA
];
27483 if (draw
== DRAW_NORMAL_TEXT
)
27484 row
->fill_line_p
= 1; /* Clear to end of line */
27487 if (end_hpos
> start_hpos
)
27489 draw_row_with_mouse_face (w
, start_x
, row
,
27490 start_hpos
, end_hpos
, draw
);
27493 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
27497 #ifdef HAVE_WINDOW_SYSTEM
27498 /* When we've written over the cursor, arrange for it to
27499 be displayed again. */
27500 if (FRAME_WINDOW_P (f
)
27501 && phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
27503 int hpos
= w
->phys_cursor
.hpos
;
27505 /* When the window is hscrolled, cursor hpos can legitimately be
27506 out of bounds, but we draw the cursor at the corresponding
27507 window margin in that case. */
27508 if (!row
->reversed_p
&& hpos
< 0)
27510 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
27511 hpos
= row
->used
[TEXT_AREA
] - 1;
27514 display_and_set_cursor (w
, 1, hpos
, w
->phys_cursor
.vpos
,
27515 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
27518 #endif /* HAVE_WINDOW_SYSTEM */
27521 #ifdef HAVE_WINDOW_SYSTEM
27522 /* Change the mouse cursor. */
27523 if (FRAME_WINDOW_P (f
))
27525 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
27526 if (draw
== DRAW_NORMAL_TEXT
27527 && !EQ (hlinfo
->mouse_face_window
, f
->tool_bar_window
))
27528 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
27531 if (draw
== DRAW_MOUSE_FACE
)
27532 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
27534 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
27536 #endif /* HAVE_WINDOW_SYSTEM */
27540 Clear out the mouse-highlighted active region.
27541 Redraw it un-highlighted first. Value is non-zero if mouse
27542 face was actually drawn unhighlighted. */
27545 clear_mouse_face (Mouse_HLInfo
*hlinfo
)
27549 if (!hlinfo
->mouse_face_hidden
&& !NILP (hlinfo
->mouse_face_window
))
27551 show_mouse_face (hlinfo
, DRAW_NORMAL_TEXT
);
27555 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
27556 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
27557 hlinfo
->mouse_face_window
= Qnil
;
27558 hlinfo
->mouse_face_overlay
= Qnil
;
27562 /* Return true if the coordinates HPOS and VPOS on windows W are
27563 within the mouse face on that window. */
27565 coords_in_mouse_face_p (struct window
*w
, int hpos
, int vpos
)
27567 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
27569 /* Quickly resolve the easy cases. */
27570 if (!(WINDOWP (hlinfo
->mouse_face_window
)
27571 && XWINDOW (hlinfo
->mouse_face_window
) == w
))
27573 if (vpos
< hlinfo
->mouse_face_beg_row
27574 || vpos
> hlinfo
->mouse_face_end_row
)
27576 if (vpos
> hlinfo
->mouse_face_beg_row
27577 && vpos
< hlinfo
->mouse_face_end_row
)
27580 if (!MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
)
27582 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
27584 if (hlinfo
->mouse_face_beg_col
<= hpos
&& hpos
< hlinfo
->mouse_face_end_col
)
27587 else if ((vpos
== hlinfo
->mouse_face_beg_row
27588 && hpos
>= hlinfo
->mouse_face_beg_col
)
27589 || (vpos
== hlinfo
->mouse_face_end_row
27590 && hpos
< hlinfo
->mouse_face_end_col
))
27595 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
27597 if (hlinfo
->mouse_face_end_col
< hpos
&& hpos
<= hlinfo
->mouse_face_beg_col
)
27600 else if ((vpos
== hlinfo
->mouse_face_beg_row
27601 && hpos
<= hlinfo
->mouse_face_beg_col
)
27602 || (vpos
== hlinfo
->mouse_face_end_row
27603 && hpos
> hlinfo
->mouse_face_end_col
))
27611 True if physical cursor of window W is within mouse face. */
27614 cursor_in_mouse_face_p (struct window
*w
)
27616 int hpos
= w
->phys_cursor
.hpos
;
27617 int vpos
= w
->phys_cursor
.vpos
;
27618 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
27620 /* When the window is hscrolled, cursor hpos can legitimately be out
27621 of bounds, but we draw the cursor at the corresponding window
27622 margin in that case. */
27623 if (!row
->reversed_p
&& hpos
< 0)
27625 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
27626 hpos
= row
->used
[TEXT_AREA
] - 1;
27628 return coords_in_mouse_face_p (w
, hpos
, vpos
);
27633 /* Find the glyph rows START_ROW and END_ROW of window W that display
27634 characters between buffer positions START_CHARPOS and END_CHARPOS
27635 (excluding END_CHARPOS). DISP_STRING is a display string that
27636 covers these buffer positions. This is similar to
27637 row_containing_pos, but is more accurate when bidi reordering makes
27638 buffer positions change non-linearly with glyph rows. */
27640 rows_from_pos_range (struct window
*w
,
27641 ptrdiff_t start_charpos
, ptrdiff_t end_charpos
,
27642 Lisp_Object disp_string
,
27643 struct glyph_row
**start
, struct glyph_row
**end
)
27645 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
27646 int last_y
= window_text_bottom_y (w
);
27647 struct glyph_row
*row
;
27652 while (!first
->enabled_p
27653 && first
< MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
27656 /* Find the START row. */
27658 row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
;
27661 /* A row can potentially be the START row if the range of the
27662 characters it displays intersects the range
27663 [START_CHARPOS..END_CHARPOS). */
27664 if (! ((start_charpos
< MATRIX_ROW_START_CHARPOS (row
)
27665 && end_charpos
< MATRIX_ROW_START_CHARPOS (row
))
27666 /* See the commentary in row_containing_pos, for the
27667 explanation of the complicated way to check whether
27668 some position is beyond the end of the characters
27669 displayed by a row. */
27670 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (row
)
27671 || (start_charpos
== MATRIX_ROW_END_CHARPOS (row
)
27672 && !row
->ends_at_zv_p
27673 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
27674 && (end_charpos
> MATRIX_ROW_END_CHARPOS (row
)
27675 || (end_charpos
== MATRIX_ROW_END_CHARPOS (row
)
27676 && !row
->ends_at_zv_p
27677 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))))
27679 /* Found a candidate row. Now make sure at least one of the
27680 glyphs it displays has a charpos from the range
27681 [START_CHARPOS..END_CHARPOS).
27683 This is not obvious because bidi reordering could make
27684 buffer positions of a row be 1,2,3,102,101,100, and if we
27685 want to highlight characters in [50..60), we don't want
27686 this row, even though [50..60) does intersect [1..103),
27687 the range of character positions given by the row's start
27688 and end positions. */
27689 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
27690 struct glyph
*e
= g
+ row
->used
[TEXT_AREA
];
27694 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
27695 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
27696 /* A glyph that comes from DISP_STRING is by
27697 definition to be highlighted. */
27698 || EQ (g
->object
, disp_string
))
27707 /* Find the END row. */
27709 /* If the last row is partially visible, start looking for END
27710 from that row, instead of starting from FIRST. */
27711 && !(row
->enabled_p
27712 && row
->y
< last_y
&& MATRIX_ROW_BOTTOM_Y (row
) > last_y
))
27714 for ( ; row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
; row
++)
27716 struct glyph_row
*next
= row
+ 1;
27717 ptrdiff_t next_start
= MATRIX_ROW_START_CHARPOS (next
);
27719 if (!next
->enabled_p
27720 || next
>= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
)
27721 /* The first row >= START whose range of displayed characters
27722 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
27723 is the row END + 1. */
27724 || (start_charpos
< next_start
27725 && end_charpos
< next_start
)
27726 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (next
)
27727 || (start_charpos
== MATRIX_ROW_END_CHARPOS (next
)
27728 && !next
->ends_at_zv_p
27729 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))
27730 && (end_charpos
> MATRIX_ROW_END_CHARPOS (next
)
27731 || (end_charpos
== MATRIX_ROW_END_CHARPOS (next
)
27732 && !next
->ends_at_zv_p
27733 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))))
27740 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
27741 but none of the characters it displays are in the range, it is
27743 struct glyph
*g
= next
->glyphs
[TEXT_AREA
];
27744 struct glyph
*s
= g
;
27745 struct glyph
*e
= g
+ next
->used
[TEXT_AREA
];
27749 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
27750 && ((start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
27751 /* If the buffer position of the first glyph in
27752 the row is equal to END_CHARPOS, it means
27753 the last character to be highlighted is the
27754 newline of ROW, and we must consider NEXT as
27756 || (((!next
->reversed_p
&& g
== s
)
27757 || (next
->reversed_p
&& g
== e
- 1))
27758 && (g
->charpos
== end_charpos
27759 /* Special case for when NEXT is an
27760 empty line at ZV. */
27761 || (g
->charpos
== -1
27762 && !row
->ends_at_zv_p
27763 && next_start
== end_charpos
)))))
27764 /* A glyph that comes from DISP_STRING is by
27765 definition to be highlighted. */
27766 || EQ (g
->object
, disp_string
))
27775 /* The first row that ends at ZV must be the last to be
27777 else if (next
->ends_at_zv_p
)
27786 /* This function sets the mouse_face_* elements of HLINFO, assuming
27787 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
27788 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
27789 for the overlay or run of text properties specifying the mouse
27790 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
27791 before-string and after-string that must also be highlighted.
27792 DISP_STRING, if non-nil, is a display string that may cover some
27793 or all of the highlighted text. */
27796 mouse_face_from_buffer_pos (Lisp_Object window
,
27797 Mouse_HLInfo
*hlinfo
,
27798 ptrdiff_t mouse_charpos
,
27799 ptrdiff_t start_charpos
,
27800 ptrdiff_t end_charpos
,
27801 Lisp_Object before_string
,
27802 Lisp_Object after_string
,
27803 Lisp_Object disp_string
)
27805 struct window
*w
= XWINDOW (window
);
27806 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
27807 struct glyph_row
*r1
, *r2
;
27808 struct glyph
*glyph
, *end
;
27809 ptrdiff_t ignore
, pos
;
27812 eassert (NILP (disp_string
) || STRINGP (disp_string
));
27813 eassert (NILP (before_string
) || STRINGP (before_string
));
27814 eassert (NILP (after_string
) || STRINGP (after_string
));
27816 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
27817 rows_from_pos_range (w
, start_charpos
, end_charpos
, disp_string
, &r1
, &r2
);
27819 r1
= MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
);
27820 /* If the before-string or display-string contains newlines,
27821 rows_from_pos_range skips to its last row. Move back. */
27822 if (!NILP (before_string
) || !NILP (disp_string
))
27824 struct glyph_row
*prev
;
27825 while ((prev
= r1
- 1, prev
>= first
)
27826 && MATRIX_ROW_END_CHARPOS (prev
) == start_charpos
27827 && prev
->used
[TEXT_AREA
] > 0)
27829 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
27830 glyph
= beg
+ prev
->used
[TEXT_AREA
];
27831 while (--glyph
>= beg
&& INTEGERP (glyph
->object
));
27833 || !(EQ (glyph
->object
, before_string
)
27834 || EQ (glyph
->object
, disp_string
)))
27841 r2
= MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
);
27842 hlinfo
->mouse_face_past_end
= 1;
27844 else if (!NILP (after_string
))
27846 /* If the after-string has newlines, advance to its last row. */
27847 struct glyph_row
*next
;
27848 struct glyph_row
*last
27849 = MATRIX_ROW (w
->current_matrix
, w
->window_end_vpos
);
27851 for (next
= r2
+ 1;
27853 && next
->used
[TEXT_AREA
] > 0
27854 && EQ (next
->glyphs
[TEXT_AREA
]->object
, after_string
);
27858 /* The rest of the display engine assumes that mouse_face_beg_row is
27859 either above mouse_face_end_row or identical to it. But with
27860 bidi-reordered continued lines, the row for START_CHARPOS could
27861 be below the row for END_CHARPOS. If so, swap the rows and store
27862 them in correct order. */
27865 struct glyph_row
*tem
= r2
;
27871 hlinfo
->mouse_face_beg_row
= MATRIX_ROW_VPOS (r1
, w
->current_matrix
);
27872 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r2
, w
->current_matrix
);
27874 /* For a bidi-reordered row, the positions of BEFORE_STRING,
27875 AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
27876 could be anywhere in the row and in any order. The strategy
27877 below is to find the leftmost and the rightmost glyph that
27878 belongs to either of these 3 strings, or whose position is
27879 between START_CHARPOS and END_CHARPOS, and highlight all the
27880 glyphs between those two. This may cover more than just the text
27881 between START_CHARPOS and END_CHARPOS if the range of characters
27882 strides the bidi level boundary, e.g. if the beginning is in R2L
27883 text while the end is in L2R text or vice versa. */
27884 if (!r1
->reversed_p
)
27886 /* This row is in a left to right paragraph. Scan it left to
27888 glyph
= r1
->glyphs
[TEXT_AREA
];
27889 end
= glyph
+ r1
->used
[TEXT_AREA
];
27892 /* Skip truncation glyphs at the start of the glyph row. */
27893 if (MATRIX_ROW_DISPLAYS_TEXT_P (r1
))
27895 && INTEGERP (glyph
->object
)
27896 && glyph
->charpos
< 0;
27898 x
+= glyph
->pixel_width
;
27900 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
27901 or DISP_STRING, and the first glyph from buffer whose
27902 position is between START_CHARPOS and END_CHARPOS. */
27904 && !INTEGERP (glyph
->object
)
27905 && !EQ (glyph
->object
, disp_string
)
27906 && !(BUFFERP (glyph
->object
)
27907 && (glyph
->charpos
>= start_charpos
27908 && glyph
->charpos
< end_charpos
));
27911 /* BEFORE_STRING or AFTER_STRING are only relevant if they
27912 are present at buffer positions between START_CHARPOS and
27913 END_CHARPOS, or if they come from an overlay. */
27914 if (EQ (glyph
->object
, before_string
))
27916 pos
= string_buffer_position (before_string
,
27918 /* If pos == 0, it means before_string came from an
27919 overlay, not from a buffer position. */
27920 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
27923 else if (EQ (glyph
->object
, after_string
))
27925 pos
= string_buffer_position (after_string
, end_charpos
);
27926 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
27929 x
+= glyph
->pixel_width
;
27931 hlinfo
->mouse_face_beg_x
= x
;
27932 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
27936 /* This row is in a right to left paragraph. Scan it right to
27940 end
= r1
->glyphs
[TEXT_AREA
] - 1;
27941 glyph
= end
+ r1
->used
[TEXT_AREA
];
27943 /* Skip truncation glyphs at the start of the glyph row. */
27944 if (MATRIX_ROW_DISPLAYS_TEXT_P (r1
))
27946 && INTEGERP (glyph
->object
)
27947 && glyph
->charpos
< 0;
27951 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
27952 or DISP_STRING, and the first glyph from buffer whose
27953 position is between START_CHARPOS and END_CHARPOS. */
27955 && !INTEGERP (glyph
->object
)
27956 && !EQ (glyph
->object
, disp_string
)
27957 && !(BUFFERP (glyph
->object
)
27958 && (glyph
->charpos
>= start_charpos
27959 && glyph
->charpos
< end_charpos
));
27962 /* BEFORE_STRING or AFTER_STRING are only relevant if they
27963 are present at buffer positions between START_CHARPOS and
27964 END_CHARPOS, or if they come from an overlay. */
27965 if (EQ (glyph
->object
, before_string
))
27967 pos
= string_buffer_position (before_string
, start_charpos
);
27968 /* If pos == 0, it means before_string came from an
27969 overlay, not from a buffer position. */
27970 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
27973 else if (EQ (glyph
->object
, after_string
))
27975 pos
= string_buffer_position (after_string
, end_charpos
);
27976 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
27981 glyph
++; /* first glyph to the right of the highlighted area */
27982 for (g
= r1
->glyphs
[TEXT_AREA
], x
= r1
->x
; g
< glyph
; g
++)
27983 x
+= g
->pixel_width
;
27984 hlinfo
->mouse_face_beg_x
= x
;
27985 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
27988 /* If the highlight ends in a different row, compute GLYPH and END
27989 for the end row. Otherwise, reuse the values computed above for
27990 the row where the highlight begins. */
27993 if (!r2
->reversed_p
)
27995 glyph
= r2
->glyphs
[TEXT_AREA
];
27996 end
= glyph
+ r2
->used
[TEXT_AREA
];
28001 end
= r2
->glyphs
[TEXT_AREA
] - 1;
28002 glyph
= end
+ r2
->used
[TEXT_AREA
];
28006 if (!r2
->reversed_p
)
28008 /* Skip truncation and continuation glyphs near the end of the
28009 row, and also blanks and stretch glyphs inserted by
28010 extend_face_to_end_of_line. */
28012 && INTEGERP ((end
- 1)->object
))
28014 /* Scan the rest of the glyph row from the end, looking for the
28015 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
28016 DISP_STRING, or whose position is between START_CHARPOS
28020 && !INTEGERP (end
->object
)
28021 && !EQ (end
->object
, disp_string
)
28022 && !(BUFFERP (end
->object
)
28023 && (end
->charpos
>= start_charpos
28024 && end
->charpos
< end_charpos
));
28027 /* BEFORE_STRING or AFTER_STRING are only relevant if they
28028 are present at buffer positions between START_CHARPOS and
28029 END_CHARPOS, or if they come from an overlay. */
28030 if (EQ (end
->object
, before_string
))
28032 pos
= string_buffer_position (before_string
, start_charpos
);
28033 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
28036 else if (EQ (end
->object
, after_string
))
28038 pos
= string_buffer_position (after_string
, end_charpos
);
28039 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
28043 /* Find the X coordinate of the last glyph to be highlighted. */
28044 for (; glyph
<= end
; ++glyph
)
28045 x
+= glyph
->pixel_width
;
28047 hlinfo
->mouse_face_end_x
= x
;
28048 hlinfo
->mouse_face_end_col
= glyph
- r2
->glyphs
[TEXT_AREA
];
28052 /* Skip truncation and continuation glyphs near the end of the
28053 row, and also blanks and stretch glyphs inserted by
28054 extend_face_to_end_of_line. */
28058 && INTEGERP (end
->object
))
28060 x
+= end
->pixel_width
;
28063 /* Scan the rest of the glyph row from the end, looking for the
28064 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
28065 DISP_STRING, or whose position is between START_CHARPOS
28069 && !INTEGERP (end
->object
)
28070 && !EQ (end
->object
, disp_string
)
28071 && !(BUFFERP (end
->object
)
28072 && (end
->charpos
>= start_charpos
28073 && end
->charpos
< end_charpos
));
28076 /* BEFORE_STRING or AFTER_STRING are only relevant if they
28077 are present at buffer positions between START_CHARPOS and
28078 END_CHARPOS, or if they come from an overlay. */
28079 if (EQ (end
->object
, before_string
))
28081 pos
= string_buffer_position (before_string
, start_charpos
);
28082 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
28085 else if (EQ (end
->object
, after_string
))
28087 pos
= string_buffer_position (after_string
, end_charpos
);
28088 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
28091 x
+= end
->pixel_width
;
28093 /* If we exited the above loop because we arrived at the last
28094 glyph of the row, and its buffer position is still not in
28095 range, it means the last character in range is the preceding
28096 newline. Bump the end column and x values to get past the
28099 && BUFFERP (end
->object
)
28100 && (end
->charpos
< start_charpos
28101 || end
->charpos
>= end_charpos
))
28103 x
+= end
->pixel_width
;
28106 hlinfo
->mouse_face_end_x
= x
;
28107 hlinfo
->mouse_face_end_col
= end
- r2
->glyphs
[TEXT_AREA
];
28110 hlinfo
->mouse_face_window
= window
;
28111 hlinfo
->mouse_face_face_id
28112 = face_at_buffer_position (w
, mouse_charpos
, &ignore
,
28114 !hlinfo
->mouse_face_hidden
, -1);
28115 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
28118 /* The following function is not used anymore (replaced with
28119 mouse_face_from_string_pos), but I leave it here for the time
28120 being, in case someone would. */
28122 #if 0 /* not used */
28124 /* Find the position of the glyph for position POS in OBJECT in
28125 window W's current matrix, and return in *X, *Y the pixel
28126 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
28128 RIGHT_P non-zero means return the position of the right edge of the
28129 glyph, RIGHT_P zero means return the left edge position.
28131 If no glyph for POS exists in the matrix, return the position of
28132 the glyph with the next smaller position that is in the matrix, if
28133 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
28134 exists in the matrix, return the position of the glyph with the
28135 next larger position in OBJECT.
28137 Value is non-zero if a glyph was found. */
28140 fast_find_string_pos (struct window
*w
, ptrdiff_t pos
, Lisp_Object object
,
28141 int *hpos
, int *vpos
, int *x
, int *y
, int right_p
)
28143 int yb
= window_text_bottom_y (w
);
28144 struct glyph_row
*r
;
28145 struct glyph
*best_glyph
= NULL
;
28146 struct glyph_row
*best_row
= NULL
;
28149 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
28150 r
->enabled_p
&& r
->y
< yb
;
28153 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
28154 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
28157 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
28158 if (EQ (g
->object
, object
))
28160 if (g
->charpos
== pos
)
28167 else if (best_glyph
== NULL
28168 || ((eabs (g
->charpos
- pos
)
28169 < eabs (best_glyph
->charpos
- pos
))
28172 : g
->charpos
> pos
)))
28186 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
28190 *x
+= best_glyph
->pixel_width
;
28195 *vpos
= MATRIX_ROW_VPOS (best_row
, w
->current_matrix
);
28198 return best_glyph
!= NULL
;
28200 #endif /* not used */
28202 /* Find the positions of the first and the last glyphs in window W's
28203 current matrix that occlude positions [STARTPOS..ENDPOS) in OBJECT
28204 (assumed to be a string), and return in HLINFO's mouse_face_*
28205 members the pixel and column/row coordinates of those glyphs. */
28208 mouse_face_from_string_pos (struct window
*w
, Mouse_HLInfo
*hlinfo
,
28209 Lisp_Object object
,
28210 ptrdiff_t startpos
, ptrdiff_t endpos
)
28212 int yb
= window_text_bottom_y (w
);
28213 struct glyph_row
*r
;
28214 struct glyph
*g
, *e
;
28218 /* Find the glyph row with at least one position in the range
28219 [STARTPOS..ENDPOS), and the first glyph in that row whose
28220 position belongs to that range. */
28221 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
28222 r
->enabled_p
&& r
->y
< yb
;
28225 if (!r
->reversed_p
)
28227 g
= r
->glyphs
[TEXT_AREA
];
28228 e
= g
+ r
->used
[TEXT_AREA
];
28229 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
28230 if (EQ (g
->object
, object
)
28231 && startpos
<= g
->charpos
&& g
->charpos
< endpos
)
28233 hlinfo
->mouse_face_beg_row
28234 = MATRIX_ROW_VPOS (r
, w
->current_matrix
);
28235 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
28236 hlinfo
->mouse_face_beg_x
= gx
;
28245 e
= r
->glyphs
[TEXT_AREA
];
28246 g
= e
+ r
->used
[TEXT_AREA
];
28247 for ( ; g
> e
; --g
)
28248 if (EQ ((g
-1)->object
, object
)
28249 && startpos
<= (g
-1)->charpos
&& (g
-1)->charpos
< endpos
)
28251 hlinfo
->mouse_face_beg_row
28252 = MATRIX_ROW_VPOS (r
, w
->current_matrix
);
28253 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
28254 for (gx
= r
->x
, g1
= r
->glyphs
[TEXT_AREA
]; g1
< g
; ++g1
)
28255 gx
+= g1
->pixel_width
;
28256 hlinfo
->mouse_face_beg_x
= gx
;
28268 /* Starting with the next row, look for the first row which does NOT
28269 include any glyphs whose positions are in the range. */
28270 for (++r
; r
->enabled_p
&& r
->y
< yb
; ++r
)
28272 g
= r
->glyphs
[TEXT_AREA
];
28273 e
= g
+ r
->used
[TEXT_AREA
];
28275 for ( ; g
< e
; ++g
)
28276 if (EQ (g
->object
, object
)
28277 && startpos
<= g
->charpos
&& g
->charpos
< endpos
)
28286 /* The highlighted region ends on the previous row. */
28289 /* Set the end row. */
28290 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r
, w
->current_matrix
);
28292 /* Compute and set the end column and the end column's horizontal
28293 pixel coordinate. */
28294 if (!r
->reversed_p
)
28296 g
= r
->glyphs
[TEXT_AREA
];
28297 e
= g
+ r
->used
[TEXT_AREA
];
28298 for ( ; e
> g
; --e
)
28299 if (EQ ((e
-1)->object
, object
)
28300 && startpos
<= (e
-1)->charpos
&& (e
-1)->charpos
< endpos
)
28302 hlinfo
->mouse_face_end_col
= e
- g
;
28304 for (gx
= r
->x
; g
< e
; ++g
)
28305 gx
+= g
->pixel_width
;
28306 hlinfo
->mouse_face_end_x
= gx
;
28310 e
= r
->glyphs
[TEXT_AREA
];
28311 g
= e
+ r
->used
[TEXT_AREA
];
28312 for (gx
= r
->x
; e
< g
; ++e
)
28314 if (EQ (e
->object
, object
)
28315 && startpos
<= e
->charpos
&& e
->charpos
< endpos
)
28317 gx
+= e
->pixel_width
;
28319 hlinfo
->mouse_face_end_col
= e
- r
->glyphs
[TEXT_AREA
];
28320 hlinfo
->mouse_face_end_x
= gx
;
28324 #ifdef HAVE_WINDOW_SYSTEM
28326 /* See if position X, Y is within a hot-spot of an image. */
28329 on_hot_spot_p (Lisp_Object hot_spot
, int x
, int y
)
28331 if (!CONSP (hot_spot
))
28334 if (EQ (XCAR (hot_spot
), Qrect
))
28336 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
28337 Lisp_Object rect
= XCDR (hot_spot
);
28341 if (!CONSP (XCAR (rect
)))
28343 if (!CONSP (XCDR (rect
)))
28345 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
28347 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
28349 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
28351 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
28355 else if (EQ (XCAR (hot_spot
), Qcircle
))
28357 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
28358 Lisp_Object circ
= XCDR (hot_spot
);
28359 Lisp_Object lr
, lx0
, ly0
;
28361 && CONSP (XCAR (circ
))
28362 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
28363 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
28364 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
28366 double r
= XFLOATINT (lr
);
28367 double dx
= XINT (lx0
) - x
;
28368 double dy
= XINT (ly0
) - y
;
28369 return (dx
* dx
+ dy
* dy
<= r
* r
);
28372 else if (EQ (XCAR (hot_spot
), Qpoly
))
28374 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
28375 if (VECTORP (XCDR (hot_spot
)))
28377 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
28378 Lisp_Object
*poly
= v
->contents
;
28379 ptrdiff_t n
= v
->header
.size
;
28382 Lisp_Object lx
, ly
;
28385 /* Need an even number of coordinates, and at least 3 edges. */
28386 if (n
< 6 || n
& 1)
28389 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
28390 If count is odd, we are inside polygon. Pixels on edges
28391 may or may not be included depending on actual geometry of the
28393 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
28394 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
28396 x0
= XINT (lx
), y0
= XINT (ly
);
28397 for (i
= 0; i
< n
; i
+= 2)
28399 int x1
= x0
, y1
= y0
;
28400 if ((lx
= poly
[i
], !INTEGERP (lx
))
28401 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
28403 x0
= XINT (lx
), y0
= XINT (ly
);
28405 /* Does this segment cross the X line? */
28413 if (y
> y0
&& y
> y1
)
28415 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
28425 find_hot_spot (Lisp_Object map
, int x
, int y
)
28427 while (CONSP (map
))
28429 if (CONSP (XCAR (map
))
28430 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
28438 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
28440 doc
: /* Lookup in image map MAP coordinates X and Y.
28441 An image map is an alist where each element has the format (AREA ID PLIST).
28442 An AREA is specified as either a rectangle, a circle, or a polygon:
28443 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
28444 pixel coordinates of the upper left and bottom right corners.
28445 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
28446 and the radius of the circle; r may be a float or integer.
28447 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
28448 vector describes one corner in the polygon.
28449 Returns the alist element for the first matching AREA in MAP. */)
28450 (Lisp_Object map
, Lisp_Object x
, Lisp_Object y
)
28458 return find_hot_spot (map
,
28459 clip_to_bounds (INT_MIN
, XINT (x
), INT_MAX
),
28460 clip_to_bounds (INT_MIN
, XINT (y
), INT_MAX
));
28464 /* Display frame CURSOR, optionally using shape defined by POINTER. */
28466 define_frame_cursor1 (struct frame
*f
, Cursor cursor
, Lisp_Object pointer
)
28468 /* Do not change cursor shape while dragging mouse. */
28469 if (!NILP (do_mouse_tracking
))
28472 if (!NILP (pointer
))
28474 if (EQ (pointer
, Qarrow
))
28475 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28476 else if (EQ (pointer
, Qhand
))
28477 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
28478 else if (EQ (pointer
, Qtext
))
28479 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
28480 else if (EQ (pointer
, intern ("hdrag")))
28481 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
28482 else if (EQ (pointer
, intern ("nhdrag")))
28483 cursor
= FRAME_X_OUTPUT (f
)->vertical_drag_cursor
;
28484 #ifdef HAVE_X_WINDOWS
28485 else if (EQ (pointer
, intern ("vdrag")))
28486 cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
28488 else if (EQ (pointer
, intern ("hourglass")))
28489 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
28490 else if (EQ (pointer
, Qmodeline
))
28491 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
28493 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28496 if (cursor
!= No_Cursor
)
28497 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
28500 #endif /* HAVE_WINDOW_SYSTEM */
28502 /* Take proper action when mouse has moved to the mode or header line
28503 or marginal area AREA of window W, x-position X and y-position Y.
28504 X is relative to the start of the text display area of W, so the
28505 width of bitmap areas and scroll bars must be subtracted to get a
28506 position relative to the start of the mode line. */
28509 note_mode_line_or_margin_highlight (Lisp_Object window
, int x
, int y
,
28510 enum window_part area
)
28512 struct window
*w
= XWINDOW (window
);
28513 struct frame
*f
= XFRAME (w
->frame
);
28514 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28515 #ifdef HAVE_WINDOW_SYSTEM
28516 Display_Info
*dpyinfo
;
28518 Cursor cursor
= No_Cursor
;
28519 Lisp_Object pointer
= Qnil
;
28520 int dx
, dy
, width
, height
;
28522 Lisp_Object string
, object
= Qnil
;
28523 Lisp_Object pos
IF_LINT (= Qnil
), help
;
28525 Lisp_Object mouse_face
;
28526 int original_x_pixel
= x
;
28527 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
28528 struct glyph_row
*row
IF_LINT (= 0);
28530 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
28535 /* Kludge alert: mode_line_string takes X/Y in pixels, but
28536 returns them in row/column units! */
28537 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
28538 &object
, &dx
, &dy
, &width
, &height
);
28540 row
= (area
== ON_MODE_LINE
28541 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
28542 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
28544 /* Find the glyph under the mouse pointer. */
28545 if (row
->mode_line_p
&& row
->enabled_p
)
28547 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
28548 end
= glyph
+ row
->used
[TEXT_AREA
];
28550 for (x0
= original_x_pixel
;
28551 glyph
< end
&& x0
>= glyph
->pixel_width
;
28553 x0
-= glyph
->pixel_width
;
28561 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
28562 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
28563 returns them in row/column units! */
28564 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
28565 &object
, &dx
, &dy
, &width
, &height
);
28570 #ifdef HAVE_WINDOW_SYSTEM
28571 if (IMAGEP (object
))
28573 Lisp_Object image_map
, hotspot
;
28574 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
28576 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
28578 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
28582 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
28583 If so, we could look for mouse-enter, mouse-leave
28584 properties in PLIST (and do something...). */
28585 hotspot
= XCDR (hotspot
);
28586 if (CONSP (hotspot
)
28587 && (plist
= XCAR (hotspot
), CONSP (plist
)))
28589 pointer
= Fplist_get (plist
, Qpointer
);
28590 if (NILP (pointer
))
28592 help
= Fplist_get (plist
, Qhelp_echo
);
28595 help_echo_string
= help
;
28596 XSETWINDOW (help_echo_window
, w
);
28597 help_echo_object
= w
->contents
;
28598 help_echo_pos
= charpos
;
28602 if (NILP (pointer
))
28603 pointer
= Fplist_get (XCDR (object
), QCpointer
);
28605 #endif /* HAVE_WINDOW_SYSTEM */
28607 if (STRINGP (string
))
28608 pos
= make_number (charpos
);
28610 /* Set the help text and mouse pointer. If the mouse is on a part
28611 of the mode line without any text (e.g. past the right edge of
28612 the mode line text), use the default help text and pointer. */
28613 if (STRINGP (string
) || area
== ON_MODE_LINE
)
28615 /* Arrange to display the help by setting the global variables
28616 help_echo_string, help_echo_object, and help_echo_pos. */
28619 if (STRINGP (string
))
28620 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
28624 help_echo_string
= help
;
28625 XSETWINDOW (help_echo_window
, w
);
28626 help_echo_object
= string
;
28627 help_echo_pos
= charpos
;
28629 else if (area
== ON_MODE_LINE
)
28631 Lisp_Object default_help
28632 = buffer_local_value (Qmode_line_default_help_echo
,
28635 if (STRINGP (default_help
))
28637 help_echo_string
= default_help
;
28638 XSETWINDOW (help_echo_window
, w
);
28639 help_echo_object
= Qnil
;
28640 help_echo_pos
= -1;
28645 #ifdef HAVE_WINDOW_SYSTEM
28646 /* Change the mouse pointer according to what is under it. */
28647 if (FRAME_WINDOW_P (f
))
28649 bool draggable
= (! WINDOW_BOTTOMMOST_P (w
)
28651 || NILP (Vresize_mini_windows
));
28653 dpyinfo
= FRAME_DISPLAY_INFO (f
);
28654 if (STRINGP (string
))
28656 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28658 if (NILP (pointer
))
28659 pointer
= Fget_text_property (pos
, Qpointer
, string
);
28661 /* Change the mouse pointer according to what is under X/Y. */
28663 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
28666 map
= Fget_text_property (pos
, Qlocal_map
, string
);
28667 if (!KEYMAPP (map
))
28668 map
= Fget_text_property (pos
, Qkeymap
, string
);
28669 if (!KEYMAPP (map
) && draggable
)
28670 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
28673 else if (draggable
)
28674 /* Default mode-line pointer. */
28675 cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
28680 /* Change the mouse face according to what is under X/Y. */
28681 if (STRINGP (string
))
28683 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
28684 if (!NILP (Vmouse_highlight
) && !NILP (mouse_face
)
28685 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
28690 struct glyph
* tmp_glyph
;
28694 int total_pixel_width
;
28695 ptrdiff_t begpos
, endpos
, ignore
;
28699 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
28700 Qmouse_face
, string
, Qnil
);
28706 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
28708 endpos
= SCHARS (string
);
28712 /* Calculate the glyph position GPOS of GLYPH in the
28713 displayed string, relative to the beginning of the
28714 highlighted part of the string.
28716 Note: GPOS is different from CHARPOS. CHARPOS is the
28717 position of GLYPH in the internal string object. A mode
28718 line string format has structures which are converted to
28719 a flattened string by the Emacs Lisp interpreter. The
28720 internal string is an element of those structures. The
28721 displayed string is the flattened string. */
28722 tmp_glyph
= row_start_glyph
;
28723 while (tmp_glyph
< glyph
28724 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
28725 && begpos
<= tmp_glyph
->charpos
28726 && tmp_glyph
->charpos
< endpos
)))
28728 gpos
= glyph
- tmp_glyph
;
28730 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
28731 the highlighted part of the displayed string to which
28732 GLYPH belongs. Note: GSEQ_LENGTH is different from
28733 SCHARS (STRING), because the latter returns the length of
28734 the internal string. */
28735 for (tmp_glyph
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
28737 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
28738 && begpos
<= tmp_glyph
->charpos
28739 && tmp_glyph
->charpos
< endpos
));
28742 gseq_length
= gpos
+ (tmp_glyph
- glyph
) + 1;
28744 /* Calculate the total pixel width of all the glyphs between
28745 the beginning of the highlighted area and GLYPH. */
28746 total_pixel_width
= 0;
28747 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
28748 total_pixel_width
+= tmp_glyph
->pixel_width
;
28750 /* Pre calculation of re-rendering position. Note: X is in
28751 column units here, after the call to mode_line_string or
28752 marginal_area_string. */
28754 vpos
= (area
== ON_MODE_LINE
28755 ? (w
->current_matrix
)->nrows
- 1
28758 /* If GLYPH's position is included in the region that is
28759 already drawn in mouse face, we have nothing to do. */
28760 if ( EQ (window
, hlinfo
->mouse_face_window
)
28761 && (!row
->reversed_p
28762 ? (hlinfo
->mouse_face_beg_col
<= hpos
28763 && hpos
< hlinfo
->mouse_face_end_col
)
28764 /* In R2L rows we swap BEG and END, see below. */
28765 : (hlinfo
->mouse_face_end_col
<= hpos
28766 && hpos
< hlinfo
->mouse_face_beg_col
))
28767 && hlinfo
->mouse_face_beg_row
== vpos
)
28770 if (clear_mouse_face (hlinfo
))
28771 cursor
= No_Cursor
;
28773 if (!row
->reversed_p
)
28775 hlinfo
->mouse_face_beg_col
= hpos
;
28776 hlinfo
->mouse_face_beg_x
= original_x_pixel
28777 - (total_pixel_width
+ dx
);
28778 hlinfo
->mouse_face_end_col
= hpos
+ gseq_length
;
28779 hlinfo
->mouse_face_end_x
= 0;
28783 /* In R2L rows, show_mouse_face expects BEG and END
28784 coordinates to be swapped. */
28785 hlinfo
->mouse_face_end_col
= hpos
;
28786 hlinfo
->mouse_face_end_x
= original_x_pixel
28787 - (total_pixel_width
+ dx
);
28788 hlinfo
->mouse_face_beg_col
= hpos
+ gseq_length
;
28789 hlinfo
->mouse_face_beg_x
= 0;
28792 hlinfo
->mouse_face_beg_row
= vpos
;
28793 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_beg_row
;
28794 hlinfo
->mouse_face_past_end
= 0;
28795 hlinfo
->mouse_face_window
= window
;
28797 hlinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
28802 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
28804 if (NILP (pointer
))
28807 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
28808 clear_mouse_face (hlinfo
);
28810 #ifdef HAVE_WINDOW_SYSTEM
28811 if (FRAME_WINDOW_P (f
))
28812 define_frame_cursor1 (f
, cursor
, pointer
);
28818 Take proper action when the mouse has moved to position X, Y on
28819 frame F with regards to highlighting portions of display that have
28820 mouse-face properties. Also de-highlight portions of display where
28821 the mouse was before, set the mouse pointer shape as appropriate
28822 for the mouse coordinates, and activate help echo (tooltips).
28823 X and Y can be negative or out of range. */
28826 note_mouse_highlight (struct frame
*f
, int x
, int y
)
28828 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28829 enum window_part part
= ON_NOTHING
;
28830 Lisp_Object window
;
28832 Cursor cursor
= No_Cursor
;
28833 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
28836 /* When a menu is active, don't highlight because this looks odd. */
28837 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
28838 if (popup_activated ())
28842 if (!f
->glyphs_initialized_p
28843 || f
->pointer_invisible
)
28846 hlinfo
->mouse_face_mouse_x
= x
;
28847 hlinfo
->mouse_face_mouse_y
= y
;
28848 hlinfo
->mouse_face_mouse_frame
= f
;
28850 if (hlinfo
->mouse_face_defer
)
28853 /* Which window is that in? */
28854 window
= window_from_coordinates (f
, x
, y
, &part
, 1);
28856 /* If displaying active text in another window, clear that. */
28857 if (! EQ (window
, hlinfo
->mouse_face_window
)
28858 /* Also clear if we move out of text area in same window. */
28859 || (!NILP (hlinfo
->mouse_face_window
)
28862 && part
!= ON_MODE_LINE
28863 && part
!= ON_HEADER_LINE
))
28864 clear_mouse_face (hlinfo
);
28866 /* Not on a window -> return. */
28867 if (!WINDOWP (window
))
28870 /* Reset help_echo_string. It will get recomputed below. */
28871 help_echo_string
= Qnil
;
28873 /* Convert to window-relative pixel coordinates. */
28874 w
= XWINDOW (window
);
28875 frame_to_window_pixel_xy (w
, &x
, &y
);
28877 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
28878 /* Handle tool-bar window differently since it doesn't display a
28880 if (EQ (window
, f
->tool_bar_window
))
28882 note_tool_bar_highlight (f
, x
, y
);
28887 /* Mouse is on the mode, header line or margin? */
28888 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
28889 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
28891 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
28893 #ifdef HAVE_WINDOW_SYSTEM
28894 if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
28896 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28897 /* Show non-text cursor (Bug#16647). */
28905 #ifdef HAVE_WINDOW_SYSTEM
28906 if (part
== ON_VERTICAL_BORDER
)
28908 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
28909 help_echo_string
= build_string ("drag-mouse-1: resize");
28911 else if (part
== ON_RIGHT_DIVIDER
)
28913 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
28914 help_echo_string
= build_string ("drag-mouse-1: resize");
28916 else if (part
== ON_BOTTOM_DIVIDER
)
28917 if (! WINDOW_BOTTOMMOST_P (w
)
28919 || NILP (Vresize_mini_windows
))
28921 cursor
= FRAME_X_OUTPUT (f
)->vertical_drag_cursor
;
28922 help_echo_string
= build_string ("drag-mouse-1: resize");
28925 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28926 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
28927 || part
== ON_SCROLL_BAR
)
28928 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
28930 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
28933 /* Are we in a window whose display is up to date?
28934 And verify the buffer's text has not changed. */
28935 b
= XBUFFER (w
->contents
);
28936 if (part
== ON_TEXT
&& w
->window_end_valid
&& !window_outdated (w
))
28938 int hpos
, vpos
, dx
, dy
, area
= LAST_AREA
;
28940 struct glyph
*glyph
;
28941 Lisp_Object object
;
28942 Lisp_Object mouse_face
= Qnil
, position
;
28943 Lisp_Object
*overlay_vec
= NULL
;
28944 ptrdiff_t i
, noverlays
;
28945 struct buffer
*obuf
;
28946 ptrdiff_t obegv
, ozv
;
28949 /* Find the glyph under X/Y. */
28950 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
28952 #ifdef HAVE_WINDOW_SYSTEM
28953 /* Look for :pointer property on image. */
28954 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
28956 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
28957 if (img
!= NULL
&& IMAGEP (img
->spec
))
28959 Lisp_Object image_map
, hotspot
;
28960 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
28962 && (hotspot
= find_hot_spot (image_map
,
28963 glyph
->slice
.img
.x
+ dx
,
28964 glyph
->slice
.img
.y
+ dy
),
28966 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
28970 /* Could check XCAR (hotspot) to see if we enter/leave
28972 If so, we could look for mouse-enter, mouse-leave
28973 properties in PLIST (and do something...). */
28974 hotspot
= XCDR (hotspot
);
28975 if (CONSP (hotspot
)
28976 && (plist
= XCAR (hotspot
), CONSP (plist
)))
28978 pointer
= Fplist_get (plist
, Qpointer
);
28979 if (NILP (pointer
))
28981 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
28982 if (!NILP (help_echo_string
))
28984 help_echo_window
= window
;
28985 help_echo_object
= glyph
->object
;
28986 help_echo_pos
= glyph
->charpos
;
28990 if (NILP (pointer
))
28991 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
28994 #endif /* HAVE_WINDOW_SYSTEM */
28996 /* Clear mouse face if X/Y not over text. */
28998 || area
!= TEXT_AREA
28999 || !MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w
->current_matrix
, vpos
))
29000 /* Glyph's OBJECT is an integer for glyphs inserted by the
29001 display engine for its internal purposes, like truncation
29002 and continuation glyphs and blanks beyond the end of
29003 line's text on text terminals. If we are over such a
29004 glyph, we are not over any text. */
29005 || INTEGERP (glyph
->object
)
29006 /* R2L rows have a stretch glyph at their front, which
29007 stands for no text, whereas L2R rows have no glyphs at
29008 all beyond the end of text. Treat such stretch glyphs
29009 like we do with NULL glyphs in L2R rows. */
29010 || (MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
29011 && glyph
== MATRIX_ROW_GLYPH_START (w
->current_matrix
, vpos
)
29012 && glyph
->type
== STRETCH_GLYPH
29013 && glyph
->avoid_cursor_p
))
29015 if (clear_mouse_face (hlinfo
))
29016 cursor
= No_Cursor
;
29017 #ifdef HAVE_WINDOW_SYSTEM
29018 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
29020 if (area
!= TEXT_AREA
)
29021 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
29023 pointer
= Vvoid_text_area_pointer
;
29029 pos
= glyph
->charpos
;
29030 object
= glyph
->object
;
29031 if (!STRINGP (object
) && !BUFFERP (object
))
29034 /* If we get an out-of-range value, return now; avoid an error. */
29035 if (BUFFERP (object
) && pos
> BUF_Z (b
))
29038 /* Make the window's buffer temporarily current for
29039 overlays_at and compute_char_face. */
29040 obuf
= current_buffer
;
29041 current_buffer
= b
;
29047 /* Is this char mouse-active or does it have help-echo? */
29048 position
= make_number (pos
);
29050 if (BUFFERP (object
))
29052 /* Put all the overlays we want in a vector in overlay_vec. */
29053 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
29054 /* Sort overlays into increasing priority order. */
29055 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
29060 if (NILP (Vmouse_highlight
))
29062 clear_mouse_face (hlinfo
);
29063 goto check_help_echo
;
29066 same_region
= coords_in_mouse_face_p (w
, hpos
, vpos
);
29069 cursor
= No_Cursor
;
29071 /* Check mouse-face highlighting. */
29073 /* If there exists an overlay with mouse-face overlapping
29074 the one we are currently highlighting, we have to
29075 check if we enter the overlapping overlay, and then
29076 highlight only that. */
29077 || (OVERLAYP (hlinfo
->mouse_face_overlay
)
29078 && mouse_face_overlay_overlaps (hlinfo
->mouse_face_overlay
)))
29080 /* Find the highest priority overlay with a mouse-face. */
29081 Lisp_Object overlay
= Qnil
;
29082 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
29084 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
29085 if (!NILP (mouse_face
))
29086 overlay
= overlay_vec
[i
];
29089 /* If we're highlighting the same overlay as before, there's
29090 no need to do that again. */
29091 if (!NILP (overlay
) && EQ (overlay
, hlinfo
->mouse_face_overlay
))
29092 goto check_help_echo
;
29093 hlinfo
->mouse_face_overlay
= overlay
;
29095 /* Clear the display of the old active region, if any. */
29096 if (clear_mouse_face (hlinfo
))
29097 cursor
= No_Cursor
;
29099 /* If no overlay applies, get a text property. */
29100 if (NILP (overlay
))
29101 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
29103 /* Next, compute the bounds of the mouse highlighting and
29105 if (!NILP (mouse_face
) && STRINGP (object
))
29107 /* The mouse-highlighting comes from a display string
29108 with a mouse-face. */
29112 s
= Fprevious_single_property_change
29113 (make_number (pos
+ 1), Qmouse_face
, object
, Qnil
);
29114 e
= Fnext_single_property_change
29115 (position
, Qmouse_face
, object
, Qnil
);
29117 s
= make_number (0);
29119 e
= make_number (SCHARS (object
));
29120 mouse_face_from_string_pos (w
, hlinfo
, object
,
29121 XINT (s
), XINT (e
));
29122 hlinfo
->mouse_face_past_end
= 0;
29123 hlinfo
->mouse_face_window
= window
;
29124 hlinfo
->mouse_face_face_id
29125 = face_at_string_position (w
, object
, pos
, 0, &ignore
,
29126 glyph
->face_id
, 1);
29127 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
29128 cursor
= No_Cursor
;
29132 /* The mouse-highlighting, if any, comes from an overlay
29133 or text property in the buffer. */
29134 Lisp_Object buffer
IF_LINT (= Qnil
);
29135 Lisp_Object disp_string
IF_LINT (= Qnil
);
29137 if (STRINGP (object
))
29139 /* If we are on a display string with no mouse-face,
29140 check if the text under it has one. */
29141 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
29142 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
29143 pos
= string_buffer_position (object
, start
);
29146 mouse_face
= get_char_property_and_overlay
29147 (make_number (pos
), Qmouse_face
, w
->contents
, &overlay
);
29148 buffer
= w
->contents
;
29149 disp_string
= object
;
29155 disp_string
= Qnil
;
29158 if (!NILP (mouse_face
))
29160 Lisp_Object before
, after
;
29161 Lisp_Object before_string
, after_string
;
29162 /* To correctly find the limits of mouse highlight
29163 in a bidi-reordered buffer, we must not use the
29164 optimization of limiting the search in
29165 previous-single-property-change and
29166 next-single-property-change, because
29167 rows_from_pos_range needs the real start and end
29168 positions to DTRT in this case. That's because
29169 the first row visible in a window does not
29170 necessarily display the character whose position
29171 is the smallest. */
29173 = NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
29174 ? Fmarker_position (w
->start
)
29177 = NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
29178 ? make_number (BUF_Z (XBUFFER (buffer
))
29179 - w
->window_end_pos
)
29182 if (NILP (overlay
))
29184 /* Handle the text property case. */
29185 before
= Fprevious_single_property_change
29186 (make_number (pos
+ 1), Qmouse_face
, buffer
, lim1
);
29187 after
= Fnext_single_property_change
29188 (make_number (pos
), Qmouse_face
, buffer
, lim2
);
29189 before_string
= after_string
= Qnil
;
29193 /* Handle the overlay case. */
29194 before
= Foverlay_start (overlay
);
29195 after
= Foverlay_end (overlay
);
29196 before_string
= Foverlay_get (overlay
, Qbefore_string
);
29197 after_string
= Foverlay_get (overlay
, Qafter_string
);
29199 if (!STRINGP (before_string
)) before_string
= Qnil
;
29200 if (!STRINGP (after_string
)) after_string
= Qnil
;
29203 mouse_face_from_buffer_pos (window
, hlinfo
, pos
,
29206 : XFASTINT (before
),
29208 ? BUF_Z (XBUFFER (buffer
))
29209 : XFASTINT (after
),
29210 before_string
, after_string
,
29212 cursor
= No_Cursor
;
29219 /* Look for a `help-echo' property. */
29220 if (NILP (help_echo_string
)) {
29221 Lisp_Object help
, overlay
;
29223 /* Check overlays first. */
29224 help
= overlay
= Qnil
;
29225 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
29227 overlay
= overlay_vec
[i
];
29228 help
= Foverlay_get (overlay
, Qhelp_echo
);
29233 help_echo_string
= help
;
29234 help_echo_window
= window
;
29235 help_echo_object
= overlay
;
29236 help_echo_pos
= pos
;
29240 Lisp_Object obj
= glyph
->object
;
29241 ptrdiff_t charpos
= glyph
->charpos
;
29243 /* Try text properties. */
29246 && charpos
< SCHARS (obj
))
29248 help
= Fget_text_property (make_number (charpos
),
29252 /* If the string itself doesn't specify a help-echo,
29253 see if the buffer text ``under'' it does. */
29254 struct glyph_row
*r
29255 = MATRIX_ROW (w
->current_matrix
, vpos
);
29256 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
29257 ptrdiff_t p
= string_buffer_position (obj
, start
);
29260 help
= Fget_char_property (make_number (p
),
29261 Qhelp_echo
, w
->contents
);
29270 else if (BUFFERP (obj
)
29273 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
29278 help_echo_string
= help
;
29279 help_echo_window
= window
;
29280 help_echo_object
= obj
;
29281 help_echo_pos
= charpos
;
29286 #ifdef HAVE_WINDOW_SYSTEM
29287 /* Look for a `pointer' property. */
29288 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
29290 /* Check overlays first. */
29291 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
29292 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
29294 if (NILP (pointer
))
29296 Lisp_Object obj
= glyph
->object
;
29297 ptrdiff_t charpos
= glyph
->charpos
;
29299 /* Try text properties. */
29302 && charpos
< SCHARS (obj
))
29304 pointer
= Fget_text_property (make_number (charpos
),
29306 if (NILP (pointer
))
29308 /* If the string itself doesn't specify a pointer,
29309 see if the buffer text ``under'' it does. */
29310 struct glyph_row
*r
29311 = MATRIX_ROW (w
->current_matrix
, vpos
);
29312 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
29313 ptrdiff_t p
= string_buffer_position (obj
, start
);
29315 pointer
= Fget_char_property (make_number (p
),
29316 Qpointer
, w
->contents
);
29319 else if (BUFFERP (obj
)
29322 pointer
= Fget_text_property (make_number (charpos
),
29326 #endif /* HAVE_WINDOW_SYSTEM */
29330 current_buffer
= obuf
;
29335 #ifdef HAVE_WINDOW_SYSTEM
29336 if (FRAME_WINDOW_P (f
))
29337 define_frame_cursor1 (f
, cursor
, pointer
);
29339 /* This is here to prevent a compiler error, about "label at end of
29340 compound statement". */
29347 Clear any mouse-face on window W. This function is part of the
29348 redisplay interface, and is called from try_window_id and similar
29349 functions to ensure the mouse-highlight is off. */
29352 x_clear_window_mouse_face (struct window
*w
)
29354 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
29355 Lisp_Object window
;
29358 XSETWINDOW (window
, w
);
29359 if (EQ (window
, hlinfo
->mouse_face_window
))
29360 clear_mouse_face (hlinfo
);
29366 Just discard the mouse face information for frame F, if any.
29367 This is used when the size of F is changed. */
29370 cancel_mouse_face (struct frame
*f
)
29372 Lisp_Object window
;
29373 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
29375 window
= hlinfo
->mouse_face_window
;
29376 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
29377 reset_mouse_highlight (hlinfo
);
29382 /***********************************************************************
29384 ***********************************************************************/
29386 #ifdef HAVE_WINDOW_SYSTEM
29388 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
29389 which intersects rectangle R. R is in window-relative coordinates. */
29392 expose_area (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
,
29393 enum glyph_row_area area
)
29395 struct glyph
*first
= row
->glyphs
[area
];
29396 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
29397 struct glyph
*last
;
29398 int first_x
, start_x
, x
;
29400 if (area
== TEXT_AREA
&& row
->fill_line_p
)
29401 /* If row extends face to end of line write the whole line. */
29402 draw_glyphs (w
, 0, row
, area
,
29403 0, row
->used
[area
],
29404 DRAW_NORMAL_TEXT
, 0);
29407 /* Set START_X to the window-relative start position for drawing glyphs of
29408 AREA. The first glyph of the text area can be partially visible.
29409 The first glyphs of other areas cannot. */
29410 start_x
= window_box_left_offset (w
, area
);
29412 if (area
== TEXT_AREA
)
29415 /* Find the first glyph that must be redrawn. */
29417 && x
+ first
->pixel_width
< r
->x
)
29419 x
+= first
->pixel_width
;
29423 /* Find the last one. */
29427 && x
< r
->x
+ r
->width
)
29429 x
+= last
->pixel_width
;
29435 draw_glyphs (w
, first_x
- start_x
, row
, area
,
29436 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
29437 DRAW_NORMAL_TEXT
, 0);
29442 /* Redraw the parts of the glyph row ROW on window W intersecting
29443 rectangle R. R is in window-relative coordinates. Value is
29444 non-zero if mouse-face was overwritten. */
29447 expose_line (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
)
29449 eassert (row
->enabled_p
);
29451 if (row
->mode_line_p
|| w
->pseudo_window_p
)
29452 draw_glyphs (w
, 0, row
, TEXT_AREA
,
29453 0, row
->used
[TEXT_AREA
],
29454 DRAW_NORMAL_TEXT
, 0);
29457 if (row
->used
[LEFT_MARGIN_AREA
])
29458 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
29459 if (row
->used
[TEXT_AREA
])
29460 expose_area (w
, row
, r
, TEXT_AREA
);
29461 if (row
->used
[RIGHT_MARGIN_AREA
])
29462 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
29463 draw_row_fringe_bitmaps (w
, row
);
29466 return row
->mouse_face_p
;
29470 /* Redraw those parts of glyphs rows during expose event handling that
29471 overlap other rows. Redrawing of an exposed line writes over parts
29472 of lines overlapping that exposed line; this function fixes that.
29474 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
29475 row in W's current matrix that is exposed and overlaps other rows.
29476 LAST_OVERLAPPING_ROW is the last such row. */
29479 expose_overlaps (struct window
*w
,
29480 struct glyph_row
*first_overlapping_row
,
29481 struct glyph_row
*last_overlapping_row
,
29484 struct glyph_row
*row
;
29486 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
29487 if (row
->overlapping_p
)
29489 eassert (row
->enabled_p
&& !row
->mode_line_p
);
29492 if (row
->used
[LEFT_MARGIN_AREA
])
29493 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
29495 if (row
->used
[TEXT_AREA
])
29496 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
29498 if (row
->used
[RIGHT_MARGIN_AREA
])
29499 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
29505 /* Return non-zero if W's cursor intersects rectangle R. */
29508 phys_cursor_in_rect_p (struct window
*w
, XRectangle
*r
)
29510 XRectangle cr
, result
;
29511 struct glyph
*cursor_glyph
;
29512 struct glyph_row
*row
;
29514 if (w
->phys_cursor
.vpos
>= 0
29515 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
29516 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
29518 && row
->cursor_in_fringe_p
)
29520 /* Cursor is in the fringe. */
29521 cr
.x
= window_box_right_offset (w
,
29522 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
29523 ? RIGHT_MARGIN_AREA
29526 cr
.width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
29527 cr
.height
= row
->height
;
29528 return x_intersect_rectangles (&cr
, r
, &result
);
29531 cursor_glyph
= get_phys_cursor_glyph (w
);
29534 /* r is relative to W's box, but w->phys_cursor.x is relative
29535 to left edge of W's TEXT area. Adjust it. */
29536 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
29537 cr
.y
= w
->phys_cursor
.y
;
29538 cr
.width
= cursor_glyph
->pixel_width
;
29539 cr
.height
= w
->phys_cursor_height
;
29540 /* ++KFS: W32 version used W32-specific IntersectRect here, but
29541 I assume the effect is the same -- and this is portable. */
29542 return x_intersect_rectangles (&cr
, r
, &result
);
29544 /* If we don't understand the format, pretend we're not in the hot-spot. */
29550 Draw a vertical window border to the right of window W if W doesn't
29551 have vertical scroll bars. */
29554 x_draw_vertical_border (struct window
*w
)
29556 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
29558 /* We could do better, if we knew what type of scroll-bar the adjacent
29559 windows (on either side) have... But we don't :-(
29560 However, I think this works ok. ++KFS 2003-04-25 */
29562 /* Redraw borders between horizontally adjacent windows. Don't
29563 do it for frames with vertical scroll bars because either the
29564 right scroll bar of a window, or the left scroll bar of its
29565 neighbor will suffice as a border. */
29566 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
) || FRAME_RIGHT_DIVIDER_WIDTH (f
))
29569 /* Note: It is necessary to redraw both the left and the right
29570 borders, for when only this single window W is being
29572 if (!WINDOW_RIGHTMOST_P (w
)
29573 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
29575 int x0
, x1
, y0
, y1
;
29577 window_box_edges (w
, &x0
, &y0
, &x1
, &y1
);
29580 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
29583 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
29586 if (!WINDOW_LEFTMOST_P (w
)
29587 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
29589 int x0
, x1
, y0
, y1
;
29591 window_box_edges (w
, &x0
, &y0
, &x1
, &y1
);
29594 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
29597 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
29602 /* Draw window dividers for window W. */
29605 x_draw_right_divider (struct window
*w
)
29607 struct frame
*f
= WINDOW_XFRAME (w
);
29609 if (w
->mini
|| w
->pseudo_window_p
)
29611 else if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
29613 int x0
= WINDOW_RIGHT_EDGE_X (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
29614 int x1
= WINDOW_RIGHT_EDGE_X (w
);
29615 int y0
= WINDOW_TOP_EDGE_Y (w
);
29616 /* The bottom divider prevails. */
29617 int y1
= WINDOW_BOTTOM_EDGE_Y (w
) - WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
29619 FRAME_RIF (f
)->draw_window_divider (w
, x0
, x1
, y0
, y1
);
29624 x_draw_bottom_divider (struct window
*w
)
29626 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
29628 if (w
->mini
|| w
->pseudo_window_p
)
29630 else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w
))
29632 int x0
= WINDOW_LEFT_EDGE_X (w
);
29633 int x1
= WINDOW_RIGHT_EDGE_X (w
);
29634 int y0
= WINDOW_BOTTOM_EDGE_Y (w
) - WINDOW_BOTTOM_DIVIDER_WIDTH (w
);
29635 int y1
= WINDOW_BOTTOM_EDGE_Y (w
);
29637 FRAME_RIF (f
)->draw_window_divider (w
, x0
, x1
, y0
, y1
);
29641 /* Redraw the part of window W intersection rectangle FR. Pixel
29642 coordinates in FR are frame-relative. Call this function with
29643 input blocked. Value is non-zero if the exposure overwrites
29647 expose_window (struct window
*w
, XRectangle
*fr
)
29649 struct frame
*f
= XFRAME (w
->frame
);
29651 int mouse_face_overwritten_p
= 0;
29653 /* If window is not yet fully initialized, do nothing. This can
29654 happen when toolkit scroll bars are used and a window is split.
29655 Reconfiguring the scroll bar will generate an expose for a newly
29657 if (w
->current_matrix
== NULL
)
29660 /* When we're currently updating the window, display and current
29661 matrix usually don't agree. Arrange for a thorough display
29663 if (w
->must_be_updated_p
)
29665 SET_FRAME_GARBAGED (f
);
29669 /* Frame-relative pixel rectangle of W. */
29670 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
29671 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
29672 wr
.width
= WINDOW_PIXEL_WIDTH (w
);
29673 wr
.height
= WINDOW_PIXEL_HEIGHT (w
);
29675 if (x_intersect_rectangles (fr
, &wr
, &r
))
29677 int yb
= window_text_bottom_y (w
);
29678 struct glyph_row
*row
;
29679 int cursor_cleared_p
, phys_cursor_on_p
;
29680 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
29682 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
29683 r
.x
, r
.y
, r
.width
, r
.height
));
29685 /* Convert to window coordinates. */
29686 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
29687 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
29689 /* Turn off the cursor. */
29690 if (!w
->pseudo_window_p
29691 && phys_cursor_in_rect_p (w
, &r
))
29693 x_clear_cursor (w
);
29694 cursor_cleared_p
= 1;
29697 cursor_cleared_p
= 0;
29699 /* If the row containing the cursor extends face to end of line,
29700 then expose_area might overwrite the cursor outside the
29701 rectangle and thus notice_overwritten_cursor might clear
29702 w->phys_cursor_on_p. We remember the original value and
29703 check later if it is changed. */
29704 phys_cursor_on_p
= w
->phys_cursor_on_p
;
29706 /* Update lines intersecting rectangle R. */
29707 first_overlapping_row
= last_overlapping_row
= NULL
;
29708 for (row
= w
->current_matrix
->rows
;
29713 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
29715 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
29716 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
29717 || (r
.y
>= y0
&& r
.y
< y1
)
29718 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
29720 /* A header line may be overlapping, but there is no need
29721 to fix overlapping areas for them. KFS 2005-02-12 */
29722 if (row
->overlapping_p
&& !row
->mode_line_p
)
29724 if (first_overlapping_row
== NULL
)
29725 first_overlapping_row
= row
;
29726 last_overlapping_row
= row
;
29730 if (expose_line (w
, row
, &r
))
29731 mouse_face_overwritten_p
= 1;
29734 else if (row
->overlapping_p
)
29736 /* We must redraw a row overlapping the exposed area. */
29738 ? y0
+ row
->phys_height
> r
.y
29739 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
29741 if (first_overlapping_row
== NULL
)
29742 first_overlapping_row
= row
;
29743 last_overlapping_row
= row
;
29751 /* Display the mode line if there is one. */
29752 if (WINDOW_WANTS_MODELINE_P (w
)
29753 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
29755 && row
->y
< r
.y
+ r
.height
)
29757 if (expose_line (w
, row
, &r
))
29758 mouse_face_overwritten_p
= 1;
29761 if (!w
->pseudo_window_p
)
29763 /* Fix the display of overlapping rows. */
29764 if (first_overlapping_row
)
29765 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
29768 /* Draw border between windows. */
29769 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
29770 x_draw_right_divider (w
);
29772 x_draw_vertical_border (w
);
29774 if (WINDOW_BOTTOM_DIVIDER_WIDTH (w
))
29775 x_draw_bottom_divider (w
);
29777 /* Turn the cursor on again. */
29778 if (cursor_cleared_p
29779 || (phys_cursor_on_p
&& !w
->phys_cursor_on_p
))
29780 update_window_cursor (w
, 1);
29784 return mouse_face_overwritten_p
;
29789 /* Redraw (parts) of all windows in the window tree rooted at W that
29790 intersect R. R contains frame pixel coordinates. Value is
29791 non-zero if the exposure overwrites mouse-face. */
29794 expose_window_tree (struct window
*w
, XRectangle
*r
)
29796 struct frame
*f
= XFRAME (w
->frame
);
29797 int mouse_face_overwritten_p
= 0;
29799 while (w
&& !FRAME_GARBAGED_P (f
))
29801 if (WINDOWP (w
->contents
))
29802 mouse_face_overwritten_p
29803 |= expose_window_tree (XWINDOW (w
->contents
), r
);
29805 mouse_face_overwritten_p
|= expose_window (w
, r
);
29807 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
29810 return mouse_face_overwritten_p
;
29815 Redisplay an exposed area of frame F. X and Y are the upper-left
29816 corner of the exposed rectangle. W and H are width and height of
29817 the exposed area. All are pixel values. W or H zero means redraw
29818 the entire frame. */
29821 expose_frame (struct frame
*f
, int x
, int y
, int w
, int h
)
29824 int mouse_face_overwritten_p
= 0;
29826 TRACE ((stderr
, "expose_frame "));
29828 /* No need to redraw if frame will be redrawn soon. */
29829 if (FRAME_GARBAGED_P (f
))
29831 TRACE ((stderr
, " garbaged\n"));
29835 /* If basic faces haven't been realized yet, there is no point in
29836 trying to redraw anything. This can happen when we get an expose
29837 event while Emacs is starting, e.g. by moving another window. */
29838 if (FRAME_FACE_CACHE (f
) == NULL
29839 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
29841 TRACE ((stderr
, " no faces\n"));
29845 if (w
== 0 || h
== 0)
29848 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
29849 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
29859 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
29860 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
29862 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
29863 if (WINDOWP (f
->tool_bar_window
))
29864 mouse_face_overwritten_p
29865 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
29868 #ifdef HAVE_X_WINDOWS
29870 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
29871 if (WINDOWP (f
->menu_bar_window
))
29872 mouse_face_overwritten_p
29873 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
29874 #endif /* not USE_X_TOOLKIT and not USE_GTK */
29878 /* Some window managers support a focus-follows-mouse style with
29879 delayed raising of frames. Imagine a partially obscured frame,
29880 and moving the mouse into partially obscured mouse-face on that
29881 frame. The visible part of the mouse-face will be highlighted,
29882 then the WM raises the obscured frame. With at least one WM, KDE
29883 2.1, Emacs is not getting any event for the raising of the frame
29884 (even tried with SubstructureRedirectMask), only Expose events.
29885 These expose events will draw text normally, i.e. not
29886 highlighted. Which means we must redo the highlight here.
29887 Subsume it under ``we love X''. --gerd 2001-08-15 */
29888 /* Included in Windows version because Windows most likely does not
29889 do the right thing if any third party tool offers
29890 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
29891 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
29893 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
29894 if (f
== hlinfo
->mouse_face_mouse_frame
)
29896 int mouse_x
= hlinfo
->mouse_face_mouse_x
;
29897 int mouse_y
= hlinfo
->mouse_face_mouse_y
;
29898 clear_mouse_face (hlinfo
);
29899 note_mouse_highlight (f
, mouse_x
, mouse_y
);
29906 Determine the intersection of two rectangles R1 and R2. Return
29907 the intersection in *RESULT. Value is non-zero if RESULT is not
29911 x_intersect_rectangles (XRectangle
*r1
, XRectangle
*r2
, XRectangle
*result
)
29913 XRectangle
*left
, *right
;
29914 XRectangle
*upper
, *lower
;
29915 int intersection_p
= 0;
29917 /* Rearrange so that R1 is the left-most rectangle. */
29919 left
= r1
, right
= r2
;
29921 left
= r2
, right
= r1
;
29923 /* X0 of the intersection is right.x0, if this is inside R1,
29924 otherwise there is no intersection. */
29925 if (right
->x
<= left
->x
+ left
->width
)
29927 result
->x
= right
->x
;
29929 /* The right end of the intersection is the minimum of
29930 the right ends of left and right. */
29931 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
29934 /* Same game for Y. */
29936 upper
= r1
, lower
= r2
;
29938 upper
= r2
, lower
= r1
;
29940 /* The upper end of the intersection is lower.y0, if this is inside
29941 of upper. Otherwise, there is no intersection. */
29942 if (lower
->y
<= upper
->y
+ upper
->height
)
29944 result
->y
= lower
->y
;
29946 /* The lower end of the intersection is the minimum of the lower
29947 ends of upper and lower. */
29948 result
->height
= (min (lower
->y
+ lower
->height
,
29949 upper
->y
+ upper
->height
)
29951 intersection_p
= 1;
29955 return intersection_p
;
29958 #endif /* HAVE_WINDOW_SYSTEM */
29961 /***********************************************************************
29963 ***********************************************************************/
29966 syms_of_xdisp (void)
29968 Vwith_echo_area_save_vector
= Qnil
;
29969 staticpro (&Vwith_echo_area_save_vector
);
29971 Vmessage_stack
= Qnil
;
29972 staticpro (&Vmessage_stack
);
29974 DEFSYM (Qinhibit_redisplay
, "inhibit-redisplay");
29975 DEFSYM (Qredisplay_internal
, "redisplay_internal (C function)");
29977 message_dolog_marker1
= Fmake_marker ();
29978 staticpro (&message_dolog_marker1
);
29979 message_dolog_marker2
= Fmake_marker ();
29980 staticpro (&message_dolog_marker2
);
29981 message_dolog_marker3
= Fmake_marker ();
29982 staticpro (&message_dolog_marker3
);
29985 defsubr (&Sdump_frame_glyph_matrix
);
29986 defsubr (&Sdump_glyph_matrix
);
29987 defsubr (&Sdump_glyph_row
);
29988 defsubr (&Sdump_tool_bar_row
);
29989 defsubr (&Strace_redisplay
);
29990 defsubr (&Strace_to_stderr
);
29992 #ifdef HAVE_WINDOW_SYSTEM
29993 defsubr (&Stool_bar_height
);
29994 defsubr (&Slookup_image_map
);
29996 defsubr (&Sline_pixel_height
);
29997 defsubr (&Sformat_mode_line
);
29998 defsubr (&Sinvisible_p
);
29999 defsubr (&Scurrent_bidi_paragraph_direction
);
30000 defsubr (&Swindow_text_pixel_size
);
30001 defsubr (&Smove_point_visually
);
30003 DEFSYM (Qmenu_bar_update_hook
, "menu-bar-update-hook");
30004 DEFSYM (Qoverriding_terminal_local_map
, "overriding-terminal-local-map");
30005 DEFSYM (Qoverriding_local_map
, "overriding-local-map");
30006 DEFSYM (Qwindow_scroll_functions
, "window-scroll-functions");
30007 DEFSYM (Qwindow_text_change_functions
, "window-text-change-functions");
30008 DEFSYM (Qredisplay_end_trigger_functions
, "redisplay-end-trigger-functions");
30009 DEFSYM (Qinhibit_point_motion_hooks
, "inhibit-point-motion-hooks");
30010 DEFSYM (Qeval
, "eval");
30011 DEFSYM (QCdata
, ":data");
30012 DEFSYM (Qdisplay
, "display");
30013 DEFSYM (Qspace_width
, "space-width");
30014 DEFSYM (Qraise
, "raise");
30015 DEFSYM (Qslice
, "slice");
30016 DEFSYM (Qspace
, "space");
30017 DEFSYM (Qmargin
, "margin");
30018 DEFSYM (Qpointer
, "pointer");
30019 DEFSYM (Qleft_margin
, "left-margin");
30020 DEFSYM (Qright_margin
, "right-margin");
30021 DEFSYM (Qcenter
, "center");
30022 DEFSYM (Qline_height
, "line-height");
30023 DEFSYM (QCalign_to
, ":align-to");
30024 DEFSYM (QCrelative_width
, ":relative-width");
30025 DEFSYM (QCrelative_height
, ":relative-height");
30026 DEFSYM (QCeval
, ":eval");
30027 DEFSYM (QCpropertize
, ":propertize");
30028 DEFSYM (QCfile
, ":file");
30029 DEFSYM (Qfontified
, "fontified");
30030 DEFSYM (Qfontification_functions
, "fontification-functions");
30031 DEFSYM (Qtrailing_whitespace
, "trailing-whitespace");
30032 DEFSYM (Qescape_glyph
, "escape-glyph");
30033 DEFSYM (Qnobreak_space
, "nobreak-space");
30034 DEFSYM (Qimage
, "image");
30035 DEFSYM (Qtext
, "text");
30036 DEFSYM (Qboth
, "both");
30037 DEFSYM (Qboth_horiz
, "both-horiz");
30038 DEFSYM (Qtext_image_horiz
, "text-image-horiz");
30039 DEFSYM (QCmap
, ":map");
30040 DEFSYM (QCpointer
, ":pointer");
30041 DEFSYM (Qrect
, "rect");
30042 DEFSYM (Qcircle
, "circle");
30043 DEFSYM (Qpoly
, "poly");
30044 DEFSYM (Qmessage_truncate_lines
, "message-truncate-lines");
30045 DEFSYM (Qgrow_only
, "grow-only");
30046 DEFSYM (Qinhibit_menubar_update
, "inhibit-menubar-update");
30047 DEFSYM (Qinhibit_eval_during_redisplay
, "inhibit-eval-during-redisplay");
30048 DEFSYM (Qposition
, "position");
30049 DEFSYM (Qbuffer_position
, "buffer-position");
30050 DEFSYM (Qobject
, "object");
30051 DEFSYM (Qbar
, "bar");
30052 DEFSYM (Qhbar
, "hbar");
30053 DEFSYM (Qbox
, "box");
30054 DEFSYM (Qhollow
, "hollow");
30055 DEFSYM (Qhand
, "hand");
30056 DEFSYM (Qarrow
, "arrow");
30057 DEFSYM (Qinhibit_free_realized_faces
, "inhibit-free-realized-faces");
30059 list_of_error
= list1 (list2 (intern_c_string ("error"),
30060 intern_c_string ("void-variable")));
30061 staticpro (&list_of_error
);
30063 DEFSYM (Qlast_arrow_position
, "last-arrow-position");
30064 DEFSYM (Qlast_arrow_string
, "last-arrow-string");
30065 DEFSYM (Qoverlay_arrow_string
, "overlay-arrow-string");
30066 DEFSYM (Qoverlay_arrow_bitmap
, "overlay-arrow-bitmap");
30068 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
30069 staticpro (&echo_buffer
[0]);
30070 staticpro (&echo_buffer
[1]);
30072 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
30073 staticpro (&echo_area_buffer
[0]);
30074 staticpro (&echo_area_buffer
[1]);
30076 Vmessages_buffer_name
= build_pure_c_string ("*Messages*");
30077 staticpro (&Vmessages_buffer_name
);
30079 mode_line_proptrans_alist
= Qnil
;
30080 staticpro (&mode_line_proptrans_alist
);
30081 mode_line_string_list
= Qnil
;
30082 staticpro (&mode_line_string_list
);
30083 mode_line_string_face
= Qnil
;
30084 staticpro (&mode_line_string_face
);
30085 mode_line_string_face_prop
= Qnil
;
30086 staticpro (&mode_line_string_face_prop
);
30087 Vmode_line_unwind_vector
= Qnil
;
30088 staticpro (&Vmode_line_unwind_vector
);
30090 DEFSYM (Qmode_line_default_help_echo
, "mode-line-default-help-echo");
30092 help_echo_string
= Qnil
;
30093 staticpro (&help_echo_string
);
30094 help_echo_object
= Qnil
;
30095 staticpro (&help_echo_object
);
30096 help_echo_window
= Qnil
;
30097 staticpro (&help_echo_window
);
30098 previous_help_echo_string
= Qnil
;
30099 staticpro (&previous_help_echo_string
);
30100 help_echo_pos
= -1;
30102 DEFSYM (Qright_to_left
, "right-to-left");
30103 DEFSYM (Qleft_to_right
, "left-to-right");
30105 #ifdef HAVE_WINDOW_SYSTEM
30106 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p
,
30107 doc
: /* Non-nil means draw block cursor as wide as the glyph under it.
30108 For example, if a block cursor is over a tab, it will be drawn as
30109 wide as that tab on the display. */);
30110 x_stretch_cursor_p
= 0;
30113 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace
,
30114 doc
: /* Non-nil means highlight trailing whitespace.
30115 The face used for trailing whitespace is `trailing-whitespace'. */);
30116 Vshow_trailing_whitespace
= Qnil
;
30118 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display
,
30119 doc
: /* Control highlighting of non-ASCII space and hyphen chars.
30120 If the value is t, Emacs highlights non-ASCII chars which have the
30121 same appearance as an ASCII space or hyphen, using the `nobreak-space'
30122 or `escape-glyph' face respectively.
30124 U+00A0 (no-break space), U+00AD (soft hyphen), U+2010 (hyphen), and
30125 U+2011 (non-breaking hyphen) are affected.
30127 Any other non-nil value means to display these characters as a escape
30128 glyph followed by an ordinary space or hyphen.
30130 A value of nil means no special handling of these characters. */);
30131 Vnobreak_char_display
= Qt
;
30133 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer
,
30134 doc
: /* The pointer shape to show in void text areas.
30135 A value of nil means to show the text pointer. Other options are `arrow',
30136 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
30137 Vvoid_text_area_pointer
= Qarrow
;
30139 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay
,
30140 doc
: /* Non-nil means don't actually do any redisplay.
30141 This is used for internal purposes. */);
30142 Vinhibit_redisplay
= Qnil
;
30144 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string
,
30145 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
30146 Vglobal_mode_string
= Qnil
;
30148 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position
,
30149 doc
: /* Marker for where to display an arrow on top of the buffer text.
30150 This must be the beginning of a line in order to work.
30151 See also `overlay-arrow-string'. */);
30152 Voverlay_arrow_position
= Qnil
;
30154 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string
,
30155 doc
: /* String to display as an arrow in non-window frames.
30156 See also `overlay-arrow-position'. */);
30157 Voverlay_arrow_string
= build_pure_c_string ("=>");
30159 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list
,
30160 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
30161 The symbols on this list are examined during redisplay to determine
30162 where to display overlay arrows. */);
30163 Voverlay_arrow_variable_list
30164 = list1 (intern_c_string ("overlay-arrow-position"));
30166 DEFVAR_INT ("scroll-step", emacs_scroll_step
,
30167 doc
: /* The number of lines to try scrolling a window by when point moves out.
30168 If that fails to bring point back on frame, point is centered instead.
30169 If this is zero, point is always centered after it moves off frame.
30170 If you want scrolling to always be a line at a time, you should set
30171 `scroll-conservatively' to a large value rather than set this to 1. */);
30173 DEFVAR_INT ("scroll-conservatively", scroll_conservatively
,
30174 doc
: /* Scroll up to this many lines, to bring point back on screen.
30175 If point moves off-screen, redisplay will scroll by up to
30176 `scroll-conservatively' lines in order to bring point just barely
30177 onto the screen again. If that cannot be done, then redisplay
30178 recenters point as usual.
30180 If the value is greater than 100, redisplay will never recenter point,
30181 but will always scroll just enough text to bring point into view, even
30182 if you move far away.
30184 A value of zero means always recenter point if it moves off screen. */);
30185 scroll_conservatively
= 0;
30187 DEFVAR_INT ("scroll-margin", scroll_margin
,
30188 doc
: /* Number of lines of margin at the top and bottom of a window.
30189 Recenter the window whenever point gets within this many lines
30190 of the top or bottom of the window. */);
30193 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch
,
30194 doc
: /* Pixels per inch value for non-window system displays.
30195 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
30196 Vdisplay_pixels_per_inch
= make_float (72.0);
30199 DEFVAR_INT ("debug-end-pos", debug_end_pos
, doc
: /* Don't ask. */);
30202 DEFVAR_LISP ("truncate-partial-width-windows",
30203 Vtruncate_partial_width_windows
,
30204 doc
: /* Non-nil means truncate lines in windows narrower than the frame.
30205 For an integer value, truncate lines in each window narrower than the
30206 full frame width, provided the window width is less than that integer;
30207 otherwise, respect the value of `truncate-lines'.
30209 For any other non-nil value, truncate lines in all windows that do
30210 not span the full frame width.
30212 A value of nil means to respect the value of `truncate-lines'.
30214 If `word-wrap' is enabled, you might want to reduce this. */);
30215 Vtruncate_partial_width_windows
= make_number (50);
30217 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit
,
30218 doc
: /* Maximum buffer size for which line number should be displayed.
30219 If the buffer is bigger than this, the line number does not appear
30220 in the mode line. A value of nil means no limit. */);
30221 Vline_number_display_limit
= Qnil
;
30223 DEFVAR_INT ("line-number-display-limit-width",
30224 line_number_display_limit_width
,
30225 doc
: /* Maximum line width (in characters) for line number display.
30226 If the average length of the lines near point is bigger than this, then the
30227 line number may be omitted from the mode line. */);
30228 line_number_display_limit_width
= 200;
30230 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows
,
30231 doc
: /* Non-nil means highlight region even in nonselected windows. */);
30232 highlight_nonselected_windows
= 0;
30234 DEFVAR_BOOL ("multiple-frames", multiple_frames
,
30235 doc
: /* Non-nil if more than one frame is visible on this display.
30236 Minibuffer-only frames don't count, but iconified frames do.
30237 This variable is not guaranteed to be accurate except while processing
30238 `frame-title-format' and `icon-title-format'. */);
30240 DEFVAR_LISP ("frame-title-format", Vframe_title_format
,
30241 doc
: /* Template for displaying the title bar of visible frames.
30242 \(Assuming the window manager supports this feature.)
30244 This variable has the same structure as `mode-line-format', except that
30245 the %c and %l constructs are ignored. It is used only on frames for
30246 which no explicit name has been set \(see `modify-frame-parameters'). */);
30248 DEFVAR_LISP ("icon-title-format", Vicon_title_format
,
30249 doc
: /* Template for displaying the title bar of an iconified frame.
30250 \(Assuming the window manager supports this feature.)
30251 This variable has the same structure as `mode-line-format' (which see),
30252 and is used only on frames for which no explicit name has been set
30253 \(see `modify-frame-parameters'). */);
30255 = Vframe_title_format
30256 = listn (CONSTYPE_PURE
, 3,
30257 intern_c_string ("multiple-frames"),
30258 build_pure_c_string ("%b"),
30259 listn (CONSTYPE_PURE
, 4,
30260 empty_unibyte_string
,
30261 intern_c_string ("invocation-name"),
30262 build_pure_c_string ("@"),
30263 intern_c_string ("system-name")));
30265 DEFVAR_LISP ("message-log-max", Vmessage_log_max
,
30266 doc
: /* Maximum number of lines to keep in the message log buffer.
30267 If nil, disable message logging. If t, log messages but don't truncate
30268 the buffer when it becomes large. */);
30269 Vmessage_log_max
= make_number (1000);
30271 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions
,
30272 doc
: /* Functions called before redisplay, if window sizes have changed.
30273 The value should be a list of functions that take one argument.
30274 Just before redisplay, for each frame, if any of its windows have changed
30275 size since the last redisplay, or have been split or deleted,
30276 all the functions in the list are called, with the frame as argument. */);
30277 Vwindow_size_change_functions
= Qnil
;
30279 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions
,
30280 doc
: /* List of functions to call before redisplaying a window with scrolling.
30281 Each function is called with two arguments, the window and its new
30282 display-start position. Note that these functions are also called by
30283 `set-window-buffer'. Also note that the value of `window-end' is not
30284 valid when these functions are called.
30286 Warning: Do not use this feature to alter the way the window
30287 is scrolled. It is not designed for that, and such use probably won't
30289 Vwindow_scroll_functions
= Qnil
;
30291 DEFVAR_LISP ("window-text-change-functions",
30292 Vwindow_text_change_functions
,
30293 doc
: /* Functions to call in redisplay when text in the window might change. */);
30294 Vwindow_text_change_functions
= Qnil
;
30296 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions
,
30297 doc
: /* Functions called when redisplay of a window reaches the end trigger.
30298 Each function is called with two arguments, the window and the end trigger value.
30299 See `set-window-redisplay-end-trigger'. */);
30300 Vredisplay_end_trigger_functions
= Qnil
;
30302 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window
,
30303 doc
: /* Non-nil means autoselect window with mouse pointer.
30304 If nil, do not autoselect windows.
30305 A positive number means delay autoselection by that many seconds: a
30306 window is autoselected only after the mouse has remained in that
30307 window for the duration of the delay.
30308 A negative number has a similar effect, but causes windows to be
30309 autoselected only after the mouse has stopped moving. \(Because of
30310 the way Emacs compares mouse events, you will occasionally wait twice
30311 that time before the window gets selected.\)
30312 Any other value means to autoselect window instantaneously when the
30313 mouse pointer enters it.
30315 Autoselection selects the minibuffer only if it is active, and never
30316 unselects the minibuffer if it is active.
30318 When customizing this variable make sure that the actual value of
30319 `focus-follows-mouse' matches the behavior of your window manager. */);
30320 Vmouse_autoselect_window
= Qnil
;
30322 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars
,
30323 doc
: /* Non-nil means automatically resize tool-bars.
30324 This dynamically changes the tool-bar's height to the minimum height
30325 that is needed to make all tool-bar items visible.
30326 If value is `grow-only', the tool-bar's height is only increased
30327 automatically; to decrease the tool-bar height, use \\[recenter]. */);
30328 Vauto_resize_tool_bars
= Qt
;
30330 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p
,
30331 doc
: /* Non-nil means raise tool-bar buttons when the mouse moves over them. */);
30332 auto_raise_tool_bar_buttons_p
= 1;
30334 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p
,
30335 doc
: /* Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
30336 make_cursor_line_fully_visible_p
= 1;
30338 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border
,
30339 doc
: /* Border below tool-bar in pixels.
30340 If an integer, use it as the height of the border.
30341 If it is one of `internal-border-width' or `border-width', use the
30342 value of the corresponding frame parameter.
30343 Otherwise, no border is added below the tool-bar. */);
30344 Vtool_bar_border
= Qinternal_border_width
;
30346 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin
,
30347 doc
: /* Margin around tool-bar buttons in pixels.
30348 If an integer, use that for both horizontal and vertical margins.
30349 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
30350 HORZ specifying the horizontal margin, and VERT specifying the
30351 vertical margin. */);
30352 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
30354 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief
,
30355 doc
: /* Relief thickness of tool-bar buttons. */);
30356 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
30358 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style
,
30359 doc
: /* Tool bar style to use.
30361 image - show images only
30362 text - show text only
30363 both - show both, text below image
30364 both-horiz - show text to the right of the image
30365 text-image-horiz - show text to the left of the image
30366 any other - use system default or image if no system default.
30368 This variable only affects the GTK+ toolkit version of Emacs. */);
30369 Vtool_bar_style
= Qnil
;
30371 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size
,
30372 doc
: /* Maximum number of characters a label can have to be shown.
30373 The tool bar style must also show labels for this to have any effect, see
30374 `tool-bar-style'. */);
30375 tool_bar_max_label_size
= DEFAULT_TOOL_BAR_LABEL_SIZE
;
30377 DEFVAR_LISP ("fontification-functions", Vfontification_functions
,
30378 doc
: /* List of functions to call to fontify regions of text.
30379 Each function is called with one argument POS. Functions must
30380 fontify a region starting at POS in the current buffer, and give
30381 fontified regions the property `fontified'. */);
30382 Vfontification_functions
= Qnil
;
30383 Fmake_variable_buffer_local (Qfontification_functions
);
30385 DEFVAR_BOOL ("unibyte-display-via-language-environment",
30386 unibyte_display_via_language_environment
,
30387 doc
: /* Non-nil means display unibyte text according to language environment.
30388 Specifically, this means that raw bytes in the range 160-255 decimal
30389 are displayed by converting them to the equivalent multibyte characters
30390 according to the current language environment. As a result, they are
30391 displayed according to the current fontset.
30393 Note that this variable affects only how these bytes are displayed,
30394 but does not change the fact they are interpreted as raw bytes. */);
30395 unibyte_display_via_language_environment
= 0;
30397 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height
,
30398 doc
: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
30399 If a float, it specifies a fraction of the mini-window frame's height.
30400 If an integer, it specifies a number of lines. */);
30401 Vmax_mini_window_height
= make_float (0.25);
30403 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows
,
30404 doc
: /* How to resize mini-windows (the minibuffer and the echo area).
30405 A value of nil means don't automatically resize mini-windows.
30406 A value of t means resize them to fit the text displayed in them.
30407 A value of `grow-only', the default, means let mini-windows grow only;
30408 they return to their normal size when the minibuffer is closed, or the
30409 echo area becomes empty. */);
30410 Vresize_mini_windows
= Qgrow_only
;
30412 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist
,
30413 doc
: /* Alist specifying how to blink the cursor off.
30414 Each element has the form (ON-STATE . OFF-STATE). Whenever the
30415 `cursor-type' frame-parameter or variable equals ON-STATE,
30416 comparing using `equal', Emacs uses OFF-STATE to specify
30417 how to blink it off. ON-STATE and OFF-STATE are values for
30418 the `cursor-type' frame parameter.
30420 If a frame's ON-STATE has no entry in this list,
30421 the frame's other specifications determine how to blink the cursor off. */);
30422 Vblink_cursor_alist
= Qnil
;
30424 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p
,
30425 doc
: /* Allow or disallow automatic horizontal scrolling of windows.
30426 If non-nil, windows are automatically scrolled horizontally to make
30427 point visible. */);
30428 automatic_hscrolling_p
= 1;
30429 DEFSYM (Qauto_hscroll_mode
, "auto-hscroll-mode");
30431 DEFVAR_INT ("hscroll-margin", hscroll_margin
,
30432 doc
: /* How many columns away from the window edge point is allowed to get
30433 before automatic hscrolling will horizontally scroll the window. */);
30434 hscroll_margin
= 5;
30436 DEFVAR_LISP ("hscroll-step", Vhscroll_step
,
30437 doc
: /* How many columns to scroll the window when point gets too close to the edge.
30438 When point is less than `hscroll-margin' columns from the window
30439 edge, automatic hscrolling will scroll the window by the amount of columns
30440 determined by this variable. If its value is a positive integer, scroll that
30441 many columns. If it's a positive floating-point number, it specifies the
30442 fraction of the window's width to scroll. If it's nil or zero, point will be
30443 centered horizontally after the scroll. Any other value, including negative
30444 numbers, are treated as if the value were zero.
30446 Automatic hscrolling always moves point outside the scroll margin, so if
30447 point was more than scroll step columns inside the margin, the window will
30448 scroll more than the value given by the scroll step.
30450 Note that the lower bound for automatic hscrolling specified by `scroll-left'
30451 and `scroll-right' overrides this variable's effect. */);
30452 Vhscroll_step
= make_number (0);
30454 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines
,
30455 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
30456 Bind this around calls to `message' to let it take effect. */);
30457 message_truncate_lines
= 0;
30459 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook
,
30460 doc
: /* Normal hook run to update the menu bar definitions.
30461 Redisplay runs this hook before it redisplays the menu bar.
30462 This is used to update menus such as Buffers, whose contents depend on
30464 Vmenu_bar_update_hook
= Qnil
;
30466 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame
,
30467 doc
: /* Frame for which we are updating a menu.
30468 The enable predicate for a menu binding should check this variable. */);
30469 Vmenu_updating_frame
= Qnil
;
30471 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update
,
30472 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
30473 inhibit_menubar_update
= 0;
30475 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix
,
30476 doc
: /* Prefix prepended to all continuation lines at display time.
30477 The value may be a string, an image, or a stretch-glyph; it is
30478 interpreted in the same way as the value of a `display' text property.
30480 This variable is overridden by any `wrap-prefix' text or overlay
30483 To add a prefix to non-continuation lines, use `line-prefix'. */);
30484 Vwrap_prefix
= Qnil
;
30485 DEFSYM (Qwrap_prefix
, "wrap-prefix");
30486 Fmake_variable_buffer_local (Qwrap_prefix
);
30488 DEFVAR_LISP ("line-prefix", Vline_prefix
,
30489 doc
: /* Prefix prepended to all non-continuation lines at display time.
30490 The value may be a string, an image, or a stretch-glyph; it is
30491 interpreted in the same way as the value of a `display' text property.
30493 This variable is overridden by any `line-prefix' text or overlay
30496 To add a prefix to continuation lines, use `wrap-prefix'. */);
30497 Vline_prefix
= Qnil
;
30498 DEFSYM (Qline_prefix
, "line-prefix");
30499 Fmake_variable_buffer_local (Qline_prefix
);
30501 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay
,
30502 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
30503 inhibit_eval_during_redisplay
= 0;
30505 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces
,
30506 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
30507 inhibit_free_realized_faces
= 0;
30510 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id
,
30511 doc
: /* Inhibit try_window_id display optimization. */);
30512 inhibit_try_window_id
= 0;
30514 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing
,
30515 doc
: /* Inhibit try_window_reusing display optimization. */);
30516 inhibit_try_window_reusing
= 0;
30518 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement
,
30519 doc
: /* Inhibit try_cursor_movement display optimization. */);
30520 inhibit_try_cursor_movement
= 0;
30521 #endif /* GLYPH_DEBUG */
30523 DEFVAR_INT ("overline-margin", overline_margin
,
30524 doc
: /* Space between overline and text, in pixels.
30525 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
30526 margin to the character height. */);
30527 overline_margin
= 2;
30529 DEFVAR_INT ("underline-minimum-offset",
30530 underline_minimum_offset
,
30531 doc
: /* Minimum distance between baseline and underline.
30532 This can improve legibility of underlined text at small font sizes,
30533 particularly when using variable `x-use-underline-position-properties'
30534 with fonts that specify an UNDERLINE_POSITION relatively close to the
30535 baseline. The default value is 1. */);
30536 underline_minimum_offset
= 1;
30538 DEFVAR_BOOL ("display-hourglass", display_hourglass_p
,
30539 doc
: /* Non-nil means show an hourglass pointer, when Emacs is busy.
30540 This feature only works when on a window system that can change
30541 cursor shapes. */);
30542 display_hourglass_p
= 1;
30544 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay
,
30545 doc
: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
30546 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
30548 #ifdef HAVE_WINDOW_SYSTEM
30549 hourglass_atimer
= NULL
;
30550 hourglass_shown_p
= 0;
30551 #endif /* HAVE_WINDOW_SYSTEM */
30553 DEFSYM (Qglyphless_char
, "glyphless-char");
30554 DEFSYM (Qhex_code
, "hex-code");
30555 DEFSYM (Qempty_box
, "empty-box");
30556 DEFSYM (Qthin_space
, "thin-space");
30557 DEFSYM (Qzero_width
, "zero-width");
30559 DEFVAR_LISP ("pre-redisplay-function", Vpre_redisplay_function
,
30560 doc
: /* Function run just before redisplay.
30561 It is called with one argument, which is the set of windows that are to
30562 be redisplayed. This set can be nil (meaning, only the selected window),
30563 or t (meaning all windows). */);
30564 Vpre_redisplay_function
= intern ("ignore");
30566 DEFSYM (Qglyphless_char_display
, "glyphless-char-display");
30567 Fput (Qglyphless_char_display
, Qchar_table_extra_slots
, make_number (1));
30569 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display
,
30570 doc
: /* Char-table defining glyphless characters.
30571 Each element, if non-nil, should be one of the following:
30572 an ASCII acronym string: display this string in a box
30573 `hex-code': display the hexadecimal code of a character in a box
30574 `empty-box': display as an empty box
30575 `thin-space': display as 1-pixel width space
30576 `zero-width': don't display
30577 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
30578 display method for graphical terminals and text terminals respectively.
30579 GRAPHICAL and TEXT should each have one of the values listed above.
30581 The char-table has one extra slot to control the display of a character for
30582 which no font is found. This slot only takes effect on graphical terminals.
30583 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
30584 `thin-space'. The default is `empty-box'.
30586 If a character has a non-nil entry in an active display table, the
30587 display table takes effect; in this case, Emacs does not consult
30588 `glyphless-char-display' at all. */);
30589 Vglyphless_char_display
= Fmake_char_table (Qglyphless_char_display
, Qnil
);
30590 Fset_char_table_extra_slot (Vglyphless_char_display
, make_number (0),
30593 DEFVAR_LISP ("debug-on-message", Vdebug_on_message
,
30594 doc
: /* If non-nil, debug if a message matching this regexp is displayed. */);
30595 Vdebug_on_message
= Qnil
;
30597 DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause
,
30599 Vredisplay__all_windows_cause
30600 = Fmake_vector (make_number (100), make_number (0));
30602 DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause
,
30604 Vredisplay__mode_lines_cause
30605 = Fmake_vector (make_number (100), make_number (0));
30609 /* Initialize this module when Emacs starts. */
30614 CHARPOS (this_line_start_pos
) = 0;
30616 if (!noninteractive
)
30618 struct window
*m
= XWINDOW (minibuf_window
);
30619 Lisp_Object frame
= m
->frame
;
30620 struct frame
*f
= XFRAME (frame
);
30621 Lisp_Object root
= FRAME_ROOT_WINDOW (f
);
30622 struct window
*r
= XWINDOW (root
);
30625 echo_area_window
= minibuf_window
;
30627 r
->top_line
= FRAME_TOP_MARGIN (f
);
30628 r
->pixel_top
= r
->top_line
* FRAME_LINE_HEIGHT (f
);
30629 r
->total_cols
= FRAME_COLS (f
);
30630 r
->pixel_width
= r
->total_cols
* FRAME_COLUMN_WIDTH (f
);
30631 r
->total_lines
= FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
);
30632 r
->pixel_height
= r
->total_lines
* FRAME_LINE_HEIGHT (f
);
30634 m
->top_line
= FRAME_LINES (f
) - 1;
30635 m
->pixel_top
= m
->top_line
* FRAME_LINE_HEIGHT (f
);
30636 m
->total_cols
= FRAME_COLS (f
);
30637 m
->pixel_width
= m
->total_cols
* FRAME_COLUMN_WIDTH (f
);
30638 m
->total_lines
= 1;
30639 m
->pixel_height
= m
->total_lines
* FRAME_LINE_HEIGHT (f
);
30641 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
30642 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
30643 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
30645 /* The default ellipsis glyphs `...'. */
30646 for (i
= 0; i
< 3; ++i
)
30647 default_invis_vector
[i
] = make_number ('.');
30651 /* Allocate the buffer for frame titles.
30652 Also used for `format-mode-line'. */
30654 mode_line_noprop_buf
= xmalloc (size
);
30655 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
30656 mode_line_noprop_ptr
= mode_line_noprop_buf
;
30657 mode_line_target
= MODE_LINE_DISPLAY
;
30660 help_echo_showing_p
= 0;
30663 #ifdef HAVE_WINDOW_SYSTEM
30665 /* Platform-independent portion of hourglass implementation. */
30667 /* Cancel a currently active hourglass timer, and start a new one. */
30669 start_hourglass (void)
30671 struct timespec delay
;
30673 cancel_hourglass ();
30675 if (INTEGERP (Vhourglass_delay
)
30676 && XINT (Vhourglass_delay
) > 0)
30677 delay
= make_timespec (min (XINT (Vhourglass_delay
),
30678 TYPE_MAXIMUM (time_t)),
30680 else if (FLOATP (Vhourglass_delay
)
30681 && XFLOAT_DATA (Vhourglass_delay
) > 0)
30682 delay
= dtotimespec (XFLOAT_DATA (Vhourglass_delay
));
30684 delay
= make_timespec (DEFAULT_HOURGLASS_DELAY
, 0);
30688 extern void w32_note_current_window (void);
30689 w32_note_current_window ();
30691 #endif /* HAVE_NTGUI */
30693 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
30694 show_hourglass
, NULL
);
30698 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
30701 cancel_hourglass (void)
30703 if (hourglass_atimer
)
30705 cancel_atimer (hourglass_atimer
);
30706 hourglass_atimer
= NULL
;
30709 if (hourglass_shown_p
)
30713 #endif /* HAVE_WINDOW_SYSTEM */