1 /* Display generation from window structure and buffer text.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
24 Emacs separates the task of updating the display from code
25 modifying global state, e.g. buffer text. This way functions
26 operating on buffers don't also have to be concerned with updating
29 Updating the display is triggered by the Lisp interpreter when it
30 decides it's time to do it. This is done either automatically for
31 you as part of the interpreter's command loop or as the result of
32 calling Lisp functions like `sit-for'. The C function `redisplay'
33 in xdisp.c is the only entry into the inner redisplay code.
35 The following diagram shows how redisplay code is invoked. As you
36 can see, Lisp calls redisplay and vice versa. Under window systems
37 like X, some portions of the redisplay code are also called
38 asynchronously during mouse movement or expose events. It is very
39 important that these code parts do NOT use the C library (malloc,
40 free) because many C libraries under Unix are not reentrant. They
41 may also NOT call functions of the Lisp interpreter which could
42 change the interpreter's state. If you don't follow these rules,
43 you will encounter bugs which are very hard to explain.
45 +--------------+ redisplay +----------------+
46 | Lisp machine |---------------->| Redisplay code |<--+
47 +--------------+ (xdisp.c) +----------------+ |
49 +----------------------------------+ |
50 Don't use this path when called |
53 expose_window (asynchronous) |
55 X expose events -----+
57 What does redisplay do? Obviously, it has to figure out somehow what
58 has been changed since the last time the display has been updated,
59 and to make these changes visible. Preferably it would do that in
60 a moderately intelligent way, i.e. fast.
62 Changes in buffer text can be deduced from window and buffer
63 structures, and from some global variables like `beg_unchanged' and
64 `end_unchanged'. The contents of the display are additionally
65 recorded in a `glyph matrix', a two-dimensional matrix of glyph
66 structures. Each row in such a matrix corresponds to a line on the
67 display, and each glyph in a row corresponds to a column displaying
68 a character, an image, or what else. This matrix is called the
69 `current glyph matrix' or `current matrix' in redisplay
72 For buffer parts that have been changed since the last update, a
73 second glyph matrix is constructed, the so called `desired glyph
74 matrix' or short `desired matrix'. Current and desired matrix are
75 then compared to find a cheap way to update the display, e.g. by
76 reusing part of the display by scrolling lines.
78 You will find a lot of redisplay optimizations when you start
79 looking at the innards of redisplay. The overall goal of all these
80 optimizations is to make redisplay fast because it is done
81 frequently. Some of these optimizations are implemented by the
86 This function tries to update the display if the text in the
87 window did not change and did not scroll, only point moved, and
88 it did not move off the displayed portion of the text.
90 . try_window_reusing_current_matrix
92 This function reuses the current matrix of a window when text
93 has not changed, but the window start changed (e.g., due to
98 This function attempts to redisplay a window by reusing parts of
99 its existing display. It finds and reuses the part that was not
100 changed, and redraws the rest.
104 This function performs the full redisplay of a single window
105 assuming that its fonts were not changed and that the cursor
106 will not end up in the scroll margins. (Loading fonts requires
107 re-adjustment of dimensions of glyph matrices, which makes this
108 method impossible to use.)
110 These optimizations are tried in sequence (some can be skipped if
111 it is known that they are not applicable). If none of the
112 optimizations were successful, redisplay calls redisplay_windows,
113 which performs a full redisplay of all windows.
117 Desired matrices are always built per Emacs window. The function
118 `display_line' is the central function to look at if you are
119 interested. It constructs one row in a desired matrix given an
120 iterator structure containing both a buffer position and a
121 description of the environment in which the text is to be
122 displayed. But this is too early, read on.
124 Characters and pixmaps displayed for a range of buffer text depend
125 on various settings of buffers and windows, on overlays and text
126 properties, on display tables, on selective display. The good news
127 is that all this hairy stuff is hidden behind a small set of
128 interface functions taking an iterator structure (struct it)
131 Iteration over things to be displayed is then simple. It is
132 started by initializing an iterator with a call to init_iterator,
133 passing it the buffer position where to start iteration. For
134 iteration over strings, pass -1 as the position to init_iterator,
135 and call reseat_to_string when the string is ready, to initialize
136 the iterator for that string. Thereafter, calls to
137 get_next_display_element fill the iterator structure with relevant
138 information about the next thing to display. Calls to
139 set_iterator_to_next move the iterator to the next thing.
141 Besides this, an iterator also contains information about the
142 display environment in which glyphs for display elements are to be
143 produced. It has fields for the width and height of the display,
144 the information whether long lines are truncated or continued, a
145 current X and Y position, and lots of other stuff you can better
148 Glyphs in a desired matrix are normally constructed in a loop
149 calling get_next_display_element and then PRODUCE_GLYPHS. The call
150 to PRODUCE_GLYPHS will fill the iterator structure with pixel
151 information about the element being displayed and at the same time
152 produce glyphs for it. If the display element fits on the line
153 being displayed, set_iterator_to_next is called next, otherwise the
154 glyphs produced are discarded. The function display_line is the
155 workhorse of filling glyph rows in the desired matrix with glyphs.
156 In addition to producing glyphs, it also handles line truncation
157 and continuation, word wrap, and cursor positioning (for the
158 latter, see also set_cursor_from_row).
162 That just couldn't be all, could it? What about terminal types not
163 supporting operations on sub-windows of the screen? To update the
164 display on such a terminal, window-based glyph matrices are not
165 well suited. To be able to reuse part of the display (scrolling
166 lines up and down), we must instead have a view of the whole
167 screen. This is what `frame matrices' are for. They are a trick.
169 Frames on terminals like above have a glyph pool. Windows on such
170 a frame sub-allocate their glyph memory from their frame's glyph
171 pool. The frame itself is given its own glyph matrices. By
172 coincidence---or maybe something else---rows in window glyph
173 matrices are slices of corresponding rows in frame matrices. Thus
174 writing to window matrices implicitly updates a frame matrix which
175 provides us with the view of the whole screen that we originally
176 wanted to have without having to move many bytes around. To be
177 honest, there is a little bit more done, but not much more. If you
178 plan to extend that code, take a look at dispnew.c. The function
179 build_frame_matrix is a good starting point.
181 Bidirectional display.
183 Bidirectional display adds quite some hair to this already complex
184 design. The good news are that a large portion of that hairy stuff
185 is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
186 reordering engine which is called by set_iterator_to_next and
187 returns the next character to display in the visual order. See
188 commentary on bidi.c for more details. As far as redisplay is
189 concerned, the effect of calling bidi_move_to_visually_next, the
190 main interface of the reordering engine, is that the iterator gets
191 magically placed on the buffer or string position that is to be
192 displayed next. In other words, a linear iteration through the
193 buffer/string is replaced with a non-linear one. All the rest of
194 the redisplay is oblivious to the bidi reordering.
196 Well, almost oblivious---there are still complications, most of
197 them due to the fact that buffer and string positions no longer
198 change monotonously with glyph indices in a glyph row. Moreover,
199 for continued lines, the buffer positions may not even be
200 monotonously changing with vertical positions. Also, accounting
201 for face changes, overlays, etc. becomes more complex because
202 non-linear iteration could potentially skip many positions with
203 changes, and then cross them again on the way back...
205 One other prominent effect of bidirectional display is that some
206 paragraphs of text need to be displayed starting at the right
207 margin of the window---the so-called right-to-left, or R2L
208 paragraphs. R2L paragraphs are displayed with R2L glyph rows,
209 which have their reversed_p flag set. The bidi reordering engine
210 produces characters in such rows starting from the character which
211 should be the rightmost on display. PRODUCE_GLYPHS then reverses
212 the order, when it fills up the glyph row whose reversed_p flag is
213 set, by prepending each new glyph to what is already there, instead
214 of appending it. When the glyph row is complete, the function
215 extend_face_to_end_of_line fills the empty space to the left of the
216 leftmost character with special glyphs, which will display as,
217 well, empty. On text terminals, these special glyphs are simply
218 blank characters. On graphics terminals, there's a single stretch
219 glyph of a suitably computed width. Both the blanks and the
220 stretch glyph are given the face of the background of the line.
221 This way, the terminal-specific back-end can still draw the glyphs
222 left to right, even for R2L lines.
224 Bidirectional display and character compositions
226 Some scripts cannot be displayed by drawing each character
227 individually, because adjacent characters change each other's shape
228 on display. For example, Arabic and Indic scripts belong to this
231 Emacs display supports this by providing "character compositions",
232 most of which is implemented in composite.c. During the buffer
233 scan that delivers characters to PRODUCE_GLYPHS, if the next
234 character to be delivered is a composed character, the iteration
235 calls composition_reseat_it and next_element_from_composition. If
236 they succeed to compose the character with one or more of the
237 following characters, the whole sequence of characters that where
238 composed is recorded in the `struct composition_it' object that is
239 part of the buffer iterator. The composed sequence could produce
240 one or more font glyphs (called "grapheme clusters") on the screen.
241 Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
242 in the direction corresponding to the current bidi scan direction
243 (recorded in the scan_dir member of the `struct bidi_it' object
244 that is part of the buffer iterator). In particular, if the bidi
245 iterator currently scans the buffer backwards, the grapheme
246 clusters are delivered back to front. This reorders the grapheme
247 clusters as appropriate for the current bidi context. Note that
248 this means that the grapheme clusters are always stored in the
249 LGSTRING object (see composite.c) in the logical order.
251 Moving an iterator in bidirectional text
252 without producing glyphs
254 Note one important detail mentioned above: that the bidi reordering
255 engine, driven by the iterator, produces characters in R2L rows
256 starting at the character that will be the rightmost on display.
257 As far as the iterator is concerned, the geometry of such rows is
258 still left to right, i.e. the iterator "thinks" the first character
259 is at the leftmost pixel position. The iterator does not know that
260 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
261 delivers. This is important when functions from the move_it_*
262 family are used to get to certain screen position or to match
263 screen coordinates with buffer coordinates: these functions use the
264 iterator geometry, which is left to right even in R2L paragraphs.
265 This works well with most callers of move_it_*, because they need
266 to get to a specific column, and columns are still numbered in the
267 reading order, i.e. the rightmost character in a R2L paragraph is
268 still column zero. But some callers do not get well with this; a
269 notable example is mouse clicks that need to find the character
270 that corresponds to certain pixel coordinates. See
271 buffer_posn_from_coords in dispnew.c for how this is handled. */
279 #include "keyboard.h"
282 #include "termchar.h"
283 #include "dispextern.h"
284 #include "character.h"
288 #include "commands.h"
292 #include "termhooks.h"
293 #include "termopts.h"
294 #include "intervals.h"
297 #include "region-cache.h"
300 #include "blockinput.h"
302 #ifdef HAVE_X_WINDOWS
317 #ifndef FRAME_X_OUTPUT
318 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
321 #define INFINITY 10000000
323 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
324 Lisp_Object Qwindow_scroll_functions
;
325 static Lisp_Object Qwindow_text_change_functions
;
326 static Lisp_Object Qredisplay_end_trigger_functions
;
327 Lisp_Object Qinhibit_point_motion_hooks
;
328 static Lisp_Object QCeval
, QCpropertize
;
329 Lisp_Object QCfile
, QCdata
;
330 static Lisp_Object Qfontified
;
331 static Lisp_Object Qgrow_only
;
332 static Lisp_Object Qinhibit_eval_during_redisplay
;
333 static Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
334 static Lisp_Object Qright_to_left
, Qleft_to_right
;
337 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
339 /* Pointer shapes. */
340 static Lisp_Object Qarrow
, Qhand
;
343 /* Holds the list (error). */
344 static Lisp_Object list_of_error
;
346 static Lisp_Object Qfontification_functions
;
348 static Lisp_Object Qwrap_prefix
;
349 static Lisp_Object Qline_prefix
;
350 static Lisp_Object Qredisplay_internal
;
352 /* Non-nil means don't actually do any redisplay. */
354 Lisp_Object Qinhibit_redisplay
;
356 /* Names of text properties relevant for redisplay. */
358 Lisp_Object Qdisplay
;
360 Lisp_Object Qspace
, QCalign_to
;
361 static Lisp_Object QCrelative_width
, QCrelative_height
;
362 Lisp_Object Qleft_margin
, Qright_margin
;
363 static Lisp_Object Qspace_width
, Qraise
;
364 static Lisp_Object Qslice
;
366 static Lisp_Object Qmargin
, Qpointer
;
367 static Lisp_Object Qline_height
;
369 /* These setters are used only in this file, so they can be private. */
371 wset_base_line_number (struct window
*w
, Lisp_Object val
)
373 w
->base_line_number
= val
;
376 wset_base_line_pos (struct window
*w
, Lisp_Object val
)
378 w
->base_line_pos
= val
;
381 wset_column_number_displayed (struct window
*w
, Lisp_Object val
)
383 w
->column_number_displayed
= val
;
386 wset_region_showing (struct window
*w
, Lisp_Object val
)
388 w
->region_showing
= val
;
391 #ifdef HAVE_WINDOW_SYSTEM
393 /* Test if overflow newline into fringe. Called with iterator IT
394 at or past right window margin, and with IT->current_x set. */
396 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
397 (!NILP (Voverflow_newline_into_fringe) \
398 && FRAME_WINDOW_P ((IT)->f) \
399 && ((IT)->bidi_it.paragraph_dir == R2L \
400 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
401 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
402 && (IT)->current_x == (IT)->last_visible_x \
403 && (IT)->line_wrap != WORD_WRAP)
405 #else /* !HAVE_WINDOW_SYSTEM */
406 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
407 #endif /* HAVE_WINDOW_SYSTEM */
409 /* Test if the display element loaded in IT, or the underlying buffer
410 or string character, is a space or a TAB character. This is used
411 to determine where word wrapping can occur. */
413 #define IT_DISPLAYING_WHITESPACE(it) \
414 ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t')) \
415 || ((STRINGP (it->string) \
416 && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' ' \
417 || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t')) \
419 && (it->s[IT_BYTEPOS (*it)] == ' ' \
420 || it->s[IT_BYTEPOS (*it)] == '\t')) \
421 || (IT_BYTEPOS (*it) < ZV_BYTE \
422 && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' ' \
423 || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t')))) \
425 /* Name of the face used to highlight trailing whitespace. */
427 static Lisp_Object Qtrailing_whitespace
;
429 /* Name and number of the face used to highlight escape glyphs. */
431 static Lisp_Object Qescape_glyph
;
433 /* Name and number of the face used to highlight non-breaking spaces. */
435 static Lisp_Object Qnobreak_space
;
437 /* The symbol `image' which is the car of the lists used to represent
438 images in Lisp. Also a tool bar style. */
442 /* The image map types. */
444 static Lisp_Object QCpointer
;
445 static Lisp_Object Qrect
, Qcircle
, Qpoly
;
447 /* Tool bar styles */
448 Lisp_Object Qboth
, Qboth_horiz
, Qtext_image_horiz
;
450 /* Non-zero means print newline to stdout before next mini-buffer
453 int noninteractive_need_newline
;
455 /* Non-zero means print newline to message log before next message. */
457 static int message_log_need_newline
;
459 /* Three markers that message_dolog uses.
460 It could allocate them itself, but that causes trouble
461 in handling memory-full errors. */
462 static Lisp_Object message_dolog_marker1
;
463 static Lisp_Object message_dolog_marker2
;
464 static Lisp_Object message_dolog_marker3
;
466 /* The buffer position of the first character appearing entirely or
467 partially on the line of the selected window which contains the
468 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
469 redisplay optimization in redisplay_internal. */
471 static struct text_pos this_line_start_pos
;
473 /* Number of characters past the end of the line above, including the
474 terminating newline. */
476 static struct text_pos this_line_end_pos
;
478 /* The vertical positions and the height of this line. */
480 static int this_line_vpos
;
481 static int this_line_y
;
482 static int this_line_pixel_height
;
484 /* X position at which this display line starts. Usually zero;
485 negative if first character is partially visible. */
487 static int this_line_start_x
;
489 /* The smallest character position seen by move_it_* functions as they
490 move across display lines. Used to set MATRIX_ROW_START_CHARPOS of
491 hscrolled lines, see display_line. */
493 static struct text_pos this_line_min_pos
;
495 /* Buffer that this_line_.* variables are referring to. */
497 static struct buffer
*this_line_buffer
;
500 /* Values of those variables at last redisplay are stored as
501 properties on `overlay-arrow-position' symbol. However, if
502 Voverlay_arrow_position is a marker, last-arrow-position is its
503 numerical position. */
505 static Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
507 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
508 properties on a symbol in overlay-arrow-variable-list. */
510 static Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
512 Lisp_Object Qmenu_bar_update_hook
;
514 /* Nonzero if an overlay arrow has been displayed in this window. */
516 static int overlay_arrow_seen
;
518 /* Vector containing glyphs for an ellipsis `...'. */
520 static Lisp_Object default_invis_vector
[3];
522 /* This is the window where the echo area message was displayed. It
523 is always a mini-buffer window, but it may not be the same window
524 currently active as a mini-buffer. */
526 Lisp_Object echo_area_window
;
528 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
529 pushes the current message and the value of
530 message_enable_multibyte on the stack, the function restore_message
531 pops the stack and displays MESSAGE again. */
533 static Lisp_Object Vmessage_stack
;
535 /* Nonzero means multibyte characters were enabled when the echo area
536 message was specified. */
538 static int message_enable_multibyte
;
540 /* Nonzero if we should redraw the mode lines on the next redisplay. */
542 int update_mode_lines
;
544 /* Nonzero if window sizes or contents have changed since last
545 redisplay that finished. */
547 int windows_or_buffers_changed
;
549 /* Nonzero means a frame's cursor type has been changed. */
551 int cursor_type_changed
;
553 /* Nonzero after display_mode_line if %l was used and it displayed a
556 static int line_number_displayed
;
558 /* The name of the *Messages* buffer, a string. */
560 static Lisp_Object Vmessages_buffer_name
;
562 /* Current, index 0, and last displayed echo area message. Either
563 buffers from echo_buffers, or nil to indicate no message. */
565 Lisp_Object echo_area_buffer
[2];
567 /* The buffers referenced from echo_area_buffer. */
569 static Lisp_Object echo_buffer
[2];
571 /* A vector saved used in with_area_buffer to reduce consing. */
573 static Lisp_Object Vwith_echo_area_save_vector
;
575 /* Non-zero means display_echo_area should display the last echo area
576 message again. Set by redisplay_preserve_echo_area. */
578 static int display_last_displayed_message_p
;
580 /* Nonzero if echo area is being used by print; zero if being used by
583 static int message_buf_print
;
585 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
587 static Lisp_Object Qinhibit_menubar_update
;
588 static Lisp_Object Qmessage_truncate_lines
;
590 /* Set to 1 in clear_message to make redisplay_internal aware
591 of an emptied echo area. */
593 static int message_cleared_p
;
595 /* A scratch glyph row with contents used for generating truncation
596 glyphs. Also used in direct_output_for_insert. */
598 #define MAX_SCRATCH_GLYPHS 100
599 static struct glyph_row scratch_glyph_row
;
600 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
602 /* Ascent and height of the last line processed by move_it_to. */
604 static int last_max_ascent
, last_height
;
606 /* Non-zero if there's a help-echo in the echo area. */
608 int help_echo_showing_p
;
610 /* If >= 0, computed, exact values of mode-line and header-line height
611 to use in the macros CURRENT_MODE_LINE_HEIGHT and
612 CURRENT_HEADER_LINE_HEIGHT. */
614 int current_mode_line_height
, current_header_line_height
;
616 /* The maximum distance to look ahead for text properties. Values
617 that are too small let us call compute_char_face and similar
618 functions too often which is expensive. Values that are too large
619 let us call compute_char_face and alike too often because we
620 might not be interested in text properties that far away. */
622 #define TEXT_PROP_DISTANCE_LIMIT 100
624 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
625 iterator state and later restore it. This is needed because the
626 bidi iterator on bidi.c keeps a stacked cache of its states, which
627 is really a singleton. When we use scratch iterator objects to
628 move around the buffer, we can cause the bidi cache to be pushed or
629 popped, and therefore we need to restore the cache state when we
630 return to the original iterator. */
631 #define SAVE_IT(ITCOPY,ITORIG,CACHE) \
634 bidi_unshelve_cache (CACHE, 1); \
636 CACHE = bidi_shelve_cache (); \
639 #define RESTORE_IT(pITORIG,pITCOPY,CACHE) \
641 if (pITORIG != pITCOPY) \
642 *(pITORIG) = *(pITCOPY); \
643 bidi_unshelve_cache (CACHE, 0); \
649 /* Non-zero means print traces of redisplay if compiled with
650 GLYPH_DEBUG defined. */
652 int trace_redisplay_p
;
654 #endif /* GLYPH_DEBUG */
656 #ifdef DEBUG_TRACE_MOVE
657 /* Non-zero means trace with TRACE_MOVE to stderr. */
660 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
662 #define TRACE_MOVE(x) (void) 0
665 static Lisp_Object Qauto_hscroll_mode
;
667 /* Buffer being redisplayed -- for redisplay_window_error. */
669 static struct buffer
*displayed_buffer
;
671 /* Value returned from text property handlers (see below). */
676 HANDLED_RECOMPUTE_PROPS
,
677 HANDLED_OVERLAY_STRING_CONSUMED
,
681 /* A description of text properties that redisplay is interested
686 /* The name of the property. */
689 /* A unique index for the property. */
692 /* A handler function called to set up iterator IT from the property
693 at IT's current position. Value is used to steer handle_stop. */
694 enum prop_handled (*handler
) (struct it
*it
);
697 static enum prop_handled
handle_face_prop (struct it
*);
698 static enum prop_handled
handle_invisible_prop (struct it
*);
699 static enum prop_handled
handle_display_prop (struct it
*);
700 static enum prop_handled
handle_composition_prop (struct it
*);
701 static enum prop_handled
handle_overlay_change (struct it
*);
702 static enum prop_handled
handle_fontified_prop (struct it
*);
704 /* Properties handled by iterators. */
706 static struct props it_props
[] =
708 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
709 /* Handle `face' before `display' because some sub-properties of
710 `display' need to know the face. */
711 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
712 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
713 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
714 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
718 /* Value is the position described by X. If X is a marker, value is
719 the marker_position of X. Otherwise, value is X. */
721 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
723 /* Enumeration returned by some move_it_.* functions internally. */
727 /* Not used. Undefined value. */
730 /* Move ended at the requested buffer position or ZV. */
731 MOVE_POS_MATCH_OR_ZV
,
733 /* Move ended at the requested X pixel position. */
736 /* Move within a line ended at the end of a line that must be
740 /* Move within a line ended at the end of a line that would
741 be displayed truncated. */
744 /* Move within a line ended at a line end. */
748 /* This counter is used to clear the face cache every once in a while
749 in redisplay_internal. It is incremented for each redisplay.
750 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
753 #define CLEAR_FACE_CACHE_COUNT 500
754 static int clear_face_cache_count
;
756 /* Similarly for the image cache. */
758 #ifdef HAVE_WINDOW_SYSTEM
759 #define CLEAR_IMAGE_CACHE_COUNT 101
760 static int clear_image_cache_count
;
762 /* Null glyph slice */
763 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
766 /* True while redisplay_internal is in progress. */
770 static Lisp_Object Qinhibit_free_realized_faces
;
771 static Lisp_Object Qmode_line_default_help_echo
;
773 /* If a string, XTread_socket generates an event to display that string.
774 (The display is done in read_char.) */
776 Lisp_Object help_echo_string
;
777 Lisp_Object help_echo_window
;
778 Lisp_Object help_echo_object
;
779 ptrdiff_t help_echo_pos
;
781 /* Temporary variable for XTread_socket. */
783 Lisp_Object previous_help_echo_string
;
785 /* Platform-independent portion of hourglass implementation. */
787 /* Non-zero means an hourglass cursor is currently shown. */
788 int hourglass_shown_p
;
790 /* If non-null, an asynchronous timer that, when it expires, displays
791 an hourglass cursor on all frames. */
792 struct atimer
*hourglass_atimer
;
794 /* Name of the face used to display glyphless characters. */
795 Lisp_Object Qglyphless_char
;
797 /* Symbol for the purpose of Vglyphless_char_display. */
798 static Lisp_Object Qglyphless_char_display
;
800 /* Method symbols for Vglyphless_char_display. */
801 static Lisp_Object Qhex_code
, Qempty_box
, Qthin_space
, Qzero_width
;
803 /* Default pixel width of `thin-space' display method. */
804 #define THIN_SPACE_WIDTH 1
806 /* Default number of seconds to wait before displaying an hourglass
808 #define DEFAULT_HOURGLASS_DELAY 1
811 /* Function prototypes. */
813 static void setup_for_ellipsis (struct it
*, int);
814 static void set_iterator_to_next (struct it
*, int);
815 static void mark_window_display_accurate_1 (struct window
*, int);
816 static int single_display_spec_string_p (Lisp_Object
, Lisp_Object
);
817 static int display_prop_string_p (Lisp_Object
, Lisp_Object
);
818 static int cursor_row_p (struct glyph_row
*);
819 static int redisplay_mode_lines (Lisp_Object
, int);
820 static char *decode_mode_spec_coding (Lisp_Object
, char *, int);
822 static Lisp_Object
get_it_property (struct it
*it
, Lisp_Object prop
);
824 static void handle_line_prefix (struct it
*);
826 static void pint2str (char *, int, ptrdiff_t);
827 static void pint2hrstr (char *, int, ptrdiff_t);
828 static struct text_pos
run_window_scroll_functions (Lisp_Object
,
830 static void reconsider_clip_changes (struct window
*, struct buffer
*);
831 static int text_outside_line_unchanged_p (struct window
*,
832 ptrdiff_t, ptrdiff_t);
833 static void store_mode_line_noprop_char (char);
834 static int store_mode_line_noprop (const char *, int, int);
835 static void handle_stop (struct it
*);
836 static void handle_stop_backwards (struct it
*, ptrdiff_t);
837 static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
838 static void ensure_echo_area_buffers (void);
839 static Lisp_Object
unwind_with_echo_area_buffer (Lisp_Object
);
840 static Lisp_Object
with_echo_area_buffer_unwind_data (struct window
*);
841 static int with_echo_area_buffer (struct window
*, int,
842 int (*) (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t),
843 ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
844 static void clear_garbaged_frames (void);
845 static int current_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
846 static void pop_message (void);
847 static int truncate_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
848 static void set_message (const char *, Lisp_Object
, ptrdiff_t, int);
849 static int set_message_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
850 static int display_echo_area (struct window
*);
851 static int display_echo_area_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
852 static int resize_mini_window_1 (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t);
853 static Lisp_Object
unwind_redisplay (Lisp_Object
);
854 static int string_char_and_length (const unsigned char *, int *);
855 static struct text_pos
display_prop_end (struct it
*, Lisp_Object
,
857 static int compute_window_start_on_continuation_line (struct window
*);
858 static void insert_left_trunc_glyphs (struct it
*);
859 static struct glyph_row
*get_overlay_arrow_glyph_row (struct window
*,
861 static void extend_face_to_end_of_line (struct it
*);
862 static int append_space_for_newline (struct it
*, int);
863 static int cursor_row_fully_visible_p (struct window
*, int, int);
864 static int try_scrolling (Lisp_Object
, int, ptrdiff_t, ptrdiff_t, int, int);
865 static int try_cursor_movement (Lisp_Object
, struct text_pos
, int *);
866 static int trailing_whitespace_p (ptrdiff_t);
867 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
868 static void push_it (struct it
*, struct text_pos
*);
869 static void iterate_out_of_display_property (struct it
*);
870 static void pop_it (struct it
*);
871 static void sync_frame_with_window_matrix_rows (struct window
*);
872 static void select_frame_for_redisplay (Lisp_Object
);
873 static void redisplay_internal (void);
874 static int echo_area_display (int);
875 static void redisplay_windows (Lisp_Object
);
876 static void redisplay_window (Lisp_Object
, int);
877 static Lisp_Object
redisplay_window_error (Lisp_Object
);
878 static Lisp_Object
redisplay_window_0 (Lisp_Object
);
879 static Lisp_Object
redisplay_window_1 (Lisp_Object
);
880 static int set_cursor_from_row (struct window
*, struct glyph_row
*,
881 struct glyph_matrix
*, ptrdiff_t, ptrdiff_t,
883 static int update_menu_bar (struct frame
*, int, int);
884 static int try_window_reusing_current_matrix (struct window
*);
885 static int try_window_id (struct window
*);
886 static int display_line (struct it
*);
887 static int display_mode_lines (struct window
*);
888 static int display_mode_line (struct window
*, enum face_id
, Lisp_Object
);
889 static int display_mode_element (struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int);
890 static int store_mode_line_string (const char *, Lisp_Object
, int, int, int, Lisp_Object
);
891 static const char *decode_mode_spec (struct window
*, int, int, Lisp_Object
*);
892 static void display_menu_bar (struct window
*);
893 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
895 static int display_string (const char *, Lisp_Object
, Lisp_Object
,
896 ptrdiff_t, ptrdiff_t, struct it
*, int, int, int, int);
897 static void compute_line_metrics (struct it
*);
898 static void run_redisplay_end_trigger_hook (struct it
*);
899 static int get_overlay_strings (struct it
*, ptrdiff_t);
900 static int get_overlay_strings_1 (struct it
*, ptrdiff_t, int);
901 static void next_overlay_string (struct it
*);
902 static void reseat (struct it
*, struct text_pos
, int);
903 static void reseat_1 (struct it
*, struct text_pos
, int);
904 static void back_to_previous_visible_line_start (struct it
*);
905 void reseat_at_previous_visible_line_start (struct it
*);
906 static void reseat_at_next_visible_line_start (struct it
*, int);
907 static int next_element_from_ellipsis (struct it
*);
908 static int next_element_from_display_vector (struct it
*);
909 static int next_element_from_string (struct it
*);
910 static int next_element_from_c_string (struct it
*);
911 static int next_element_from_buffer (struct it
*);
912 static int next_element_from_composition (struct it
*);
913 static int next_element_from_image (struct it
*);
914 static int next_element_from_stretch (struct it
*);
915 static void load_overlay_strings (struct it
*, ptrdiff_t);
916 static int init_from_display_pos (struct it
*, struct window
*,
917 struct display_pos
*);
918 static void reseat_to_string (struct it
*, const char *,
919 Lisp_Object
, ptrdiff_t, ptrdiff_t, int, int);
920 static int get_next_display_element (struct it
*);
921 static enum move_it_result
922 move_it_in_display_line_to (struct it
*, ptrdiff_t, int,
923 enum move_operation_enum
);
924 void move_it_vertically_backward (struct it
*, int);
925 static void get_visually_first_element (struct it
*);
926 static void init_to_row_start (struct it
*, struct window
*,
928 static int init_to_row_end (struct it
*, struct window
*,
930 static void back_to_previous_line_start (struct it
*);
931 static int forward_to_next_line_start (struct it
*, int *, struct bidi_it
*);
932 static struct text_pos
string_pos_nchars_ahead (struct text_pos
,
933 Lisp_Object
, ptrdiff_t);
934 static struct text_pos
string_pos (ptrdiff_t, Lisp_Object
);
935 static struct text_pos
c_string_pos (ptrdiff_t, const char *, int);
936 static ptrdiff_t number_of_chars (const char *, int);
937 static void compute_stop_pos (struct it
*);
938 static void compute_string_pos (struct text_pos
*, struct text_pos
,
940 static int face_before_or_after_it_pos (struct it
*, int);
941 static ptrdiff_t next_overlay_change (ptrdiff_t);
942 static int handle_display_spec (struct it
*, Lisp_Object
, Lisp_Object
,
943 Lisp_Object
, struct text_pos
*, ptrdiff_t, int);
944 static int handle_single_display_spec (struct it
*, Lisp_Object
,
945 Lisp_Object
, Lisp_Object
,
946 struct text_pos
*, ptrdiff_t, int, int);
947 static int underlying_face_id (struct it
*);
948 static int in_ellipses_for_invisible_text_p (struct display_pos
*,
951 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
952 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
954 #ifdef HAVE_WINDOW_SYSTEM
956 static void x_consider_frame_title (Lisp_Object
);
957 static int tool_bar_lines_needed (struct frame
*, int *);
958 static void update_tool_bar (struct frame
*, int);
959 static void build_desired_tool_bar_string (struct frame
*f
);
960 static int redisplay_tool_bar (struct frame
*);
961 static void display_tool_bar_line (struct it
*, int);
962 static void notice_overwritten_cursor (struct window
*,
965 static void append_stretch_glyph (struct it
*, Lisp_Object
,
969 #endif /* HAVE_WINDOW_SYSTEM */
971 static void produce_special_glyphs (struct it
*, enum display_element_type
);
972 static void show_mouse_face (Mouse_HLInfo
*, enum draw_glyphs_face
);
973 static int coords_in_mouse_face_p (struct window
*, int, int);
977 /***********************************************************************
978 Window display dimensions
979 ***********************************************************************/
981 /* Return the bottom boundary y-position for text lines in window W.
982 This is the first y position at which a line cannot start.
983 It is relative to the top of the window.
985 This is the height of W minus the height of a mode line, if any. */
988 window_text_bottom_y (struct window
*w
)
990 int height
= WINDOW_TOTAL_HEIGHT (w
);
992 if (WINDOW_WANTS_MODELINE_P (w
))
993 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
997 /* Return the pixel width of display area AREA of window W. AREA < 0
998 means return the total width of W, not including fringes to
999 the left and right of the window. */
1002 window_box_width (struct window
*w
, int area
)
1004 int cols
= XFASTINT (w
->total_cols
);
1007 if (!w
->pseudo_window_p
)
1009 cols
-= WINDOW_SCROLL_BAR_COLS (w
);
1011 if (area
== TEXT_AREA
)
1013 if (INTEGERP (w
->left_margin_cols
))
1014 cols
-= XFASTINT (w
->left_margin_cols
);
1015 if (INTEGERP (w
->right_margin_cols
))
1016 cols
-= XFASTINT (w
->right_margin_cols
);
1017 pixels
= -WINDOW_TOTAL_FRINGE_WIDTH (w
);
1019 else if (area
== LEFT_MARGIN_AREA
)
1021 cols
= (INTEGERP (w
->left_margin_cols
)
1022 ? XFASTINT (w
->left_margin_cols
) : 0);
1025 else if (area
== RIGHT_MARGIN_AREA
)
1027 cols
= (INTEGERP (w
->right_margin_cols
)
1028 ? XFASTINT (w
->right_margin_cols
) : 0);
1033 return cols
* WINDOW_FRAME_COLUMN_WIDTH (w
) + pixels
;
1037 /* Return the pixel height of the display area of window W, not
1038 including mode lines of W, if any. */
1041 window_box_height (struct window
*w
)
1043 struct frame
*f
= XFRAME (w
->frame
);
1044 int height
= WINDOW_TOTAL_HEIGHT (w
);
1046 eassert (height
>= 0);
1048 /* Note: the code below that determines the mode-line/header-line
1049 height is essentially the same as that contained in the macro
1050 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1051 the appropriate glyph row has its `mode_line_p' flag set,
1052 and if it doesn't, uses estimate_mode_line_height instead. */
1054 if (WINDOW_WANTS_MODELINE_P (w
))
1056 struct glyph_row
*ml_row
1057 = (w
->current_matrix
&& w
->current_matrix
->rows
1058 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1060 if (ml_row
&& ml_row
->mode_line_p
)
1061 height
-= ml_row
->height
;
1063 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1066 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1068 struct glyph_row
*hl_row
1069 = (w
->current_matrix
&& w
->current_matrix
->rows
1070 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1072 if (hl_row
&& hl_row
->mode_line_p
)
1073 height
-= hl_row
->height
;
1075 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1078 /* With a very small font and a mode-line that's taller than
1079 default, we might end up with a negative height. */
1080 return max (0, height
);
1083 /* Return the window-relative coordinate of the left edge of display
1084 area AREA of window W. AREA < 0 means return the left edge of the
1085 whole window, to the right of the left fringe of W. */
1088 window_box_left_offset (struct window
*w
, int area
)
1092 if (w
->pseudo_window_p
)
1095 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1097 if (area
== TEXT_AREA
)
1098 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1099 + window_box_width (w
, LEFT_MARGIN_AREA
));
1100 else if (area
== RIGHT_MARGIN_AREA
)
1101 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1102 + window_box_width (w
, LEFT_MARGIN_AREA
)
1103 + window_box_width (w
, TEXT_AREA
)
1104 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1106 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1107 else if (area
== LEFT_MARGIN_AREA
1108 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1109 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1115 /* Return the window-relative coordinate of the right edge of display
1116 area AREA of window W. AREA < 0 means return the right edge of the
1117 whole window, to the left of the right fringe of W. */
1120 window_box_right_offset (struct window
*w
, int area
)
1122 return window_box_left_offset (w
, area
) + window_box_width (w
, area
);
1125 /* Return the frame-relative coordinate of the left edge of display
1126 area AREA of window W. AREA < 0 means return the left edge of the
1127 whole window, to the right of the left fringe of W. */
1130 window_box_left (struct window
*w
, int area
)
1132 struct frame
*f
= XFRAME (w
->frame
);
1135 if (w
->pseudo_window_p
)
1136 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1138 x
= (WINDOW_LEFT_EDGE_X (w
)
1139 + window_box_left_offset (w
, area
));
1145 /* Return the frame-relative coordinate of the right edge of display
1146 area AREA of window W. AREA < 0 means return the right edge of the
1147 whole window, to the left of the right fringe of W. */
1150 window_box_right (struct window
*w
, int area
)
1152 return window_box_left (w
, area
) + window_box_width (w
, area
);
1155 /* Get the bounding box of the display area AREA of window W, without
1156 mode lines, in frame-relative coordinates. AREA < 0 means the
1157 whole window, not including the left and right fringes of
1158 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1159 coordinates of the upper-left corner of the box. Return in
1160 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1163 window_box (struct window
*w
, int area
, int *box_x
, int *box_y
,
1164 int *box_width
, int *box_height
)
1167 *box_width
= window_box_width (w
, area
);
1169 *box_height
= window_box_height (w
);
1171 *box_x
= window_box_left (w
, area
);
1174 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1175 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1176 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1181 /* Get the bounding box of the display area AREA of window W, without
1182 mode lines. AREA < 0 means the whole window, not including the
1183 left and right fringe of the window. Return in *TOP_LEFT_X
1184 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1185 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1186 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1190 window_box_edges (struct window
*w
, int area
, int *top_left_x
, int *top_left_y
,
1191 int *bottom_right_x
, int *bottom_right_y
)
1193 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1195 *bottom_right_x
+= *top_left_x
;
1196 *bottom_right_y
+= *top_left_y
;
1201 /***********************************************************************
1203 ***********************************************************************/
1205 /* Return the bottom y-position of the line the iterator IT is in.
1206 This can modify IT's settings. */
1209 line_bottom_y (struct it
*it
)
1211 int line_height
= it
->max_ascent
+ it
->max_descent
;
1212 int line_top_y
= it
->current_y
;
1214 if (line_height
== 0)
1217 line_height
= last_height
;
1218 else if (IT_CHARPOS (*it
) < ZV
)
1220 move_it_by_lines (it
, 1);
1221 line_height
= (it
->max_ascent
|| it
->max_descent
1222 ? it
->max_ascent
+ it
->max_descent
1227 struct glyph_row
*row
= it
->glyph_row
;
1229 /* Use the default character height. */
1230 it
->glyph_row
= NULL
;
1231 it
->what
= IT_CHARACTER
;
1234 PRODUCE_GLYPHS (it
);
1235 line_height
= it
->ascent
+ it
->descent
;
1236 it
->glyph_row
= row
;
1240 return line_top_y
+ line_height
;
1243 /* Subroutine of pos_visible_p below. Extracts a display string, if
1244 any, from the display spec given as its argument. */
1246 string_from_display_spec (Lisp_Object spec
)
1250 while (CONSP (spec
))
1252 if (STRINGP (XCAR (spec
)))
1257 else if (VECTORP (spec
))
1261 for (i
= 0; i
< ASIZE (spec
); i
++)
1263 if (STRINGP (AREF (spec
, i
)))
1264 return AREF (spec
, i
);
1273 /* Limit insanely large values of W->hscroll on frame F to the largest
1274 value that will still prevent first_visible_x and last_visible_x of
1275 'struct it' from overflowing an int. */
1277 window_hscroll_limited (struct window
*w
, struct frame
*f
)
1279 ptrdiff_t window_hscroll
= w
->hscroll
;
1280 int window_text_width
= window_box_width (w
, TEXT_AREA
);
1281 int colwidth
= FRAME_COLUMN_WIDTH (f
);
1283 if (window_hscroll
> (INT_MAX
- window_text_width
) / colwidth
- 1)
1284 window_hscroll
= (INT_MAX
- window_text_width
) / colwidth
- 1;
1286 return window_hscroll
;
1289 /* Return 1 if position CHARPOS is visible in window W.
1290 CHARPOS < 0 means return info about WINDOW_END position.
1291 If visible, set *X and *Y to pixel coordinates of top left corner.
1292 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1293 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1296 pos_visible_p (struct window
*w
, ptrdiff_t charpos
, int *x
, int *y
,
1297 int *rtop
, int *rbot
, int *rowh
, int *vpos
)
1300 void *itdata
= bidi_shelve_cache ();
1301 struct text_pos top
;
1303 struct buffer
*old_buffer
= NULL
;
1305 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w
))))
1308 if (XBUFFER (w
->buffer
) != current_buffer
)
1310 old_buffer
= current_buffer
;
1311 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1314 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1315 /* Scrolling a minibuffer window via scroll bar when the echo area
1316 shows long text sometimes resets the minibuffer contents behind
1318 if (CHARPOS (top
) > ZV
)
1319 SET_TEXT_POS (top
, BEGV
, BEGV_BYTE
);
1321 /* Compute exact mode line heights. */
1322 if (WINDOW_WANTS_MODELINE_P (w
))
1323 current_mode_line_height
1324 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1325 BVAR (current_buffer
, mode_line_format
));
1327 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1328 current_header_line_height
1329 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1330 BVAR (current_buffer
, header_line_format
));
1332 start_display (&it
, w
, top
);
1333 move_it_to (&it
, charpos
, -1, it
.last_visible_y
-1, -1,
1334 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1337 && (((!it
.bidi_p
|| it
.bidi_it
.scan_dir
== 1)
1338 && IT_CHARPOS (it
) >= charpos
)
1339 /* When scanning backwards under bidi iteration, move_it_to
1340 stops at or _before_ CHARPOS, because it stops at or to
1341 the _right_ of the character at CHARPOS. */
1342 || (it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1343 && IT_CHARPOS (it
) <= charpos
)))
1345 /* We have reached CHARPOS, or passed it. How the call to
1346 move_it_to can overshoot: (i) If CHARPOS is on invisible text
1347 or covered by a display property, move_it_to stops at the end
1348 of the invisible text, to the right of CHARPOS. (ii) If
1349 CHARPOS is in a display vector, move_it_to stops on its last
1351 int top_x
= it
.current_x
;
1352 int top_y
= it
.current_y
;
1353 /* Calling line_bottom_y may change it.method, it.position, etc. */
1354 enum it_method it_method
= it
.method
;
1355 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1356 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1358 if (top_y
< window_top_y
)
1359 visible_p
= bottom_y
> window_top_y
;
1360 else if (top_y
< it
.last_visible_y
)
1362 if (bottom_y
>= it
.last_visible_y
1363 && it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1364 && IT_CHARPOS (it
) < charpos
)
1366 /* When the last line of the window is scanned backwards
1367 under bidi iteration, we could be duped into thinking
1368 that we have passed CHARPOS, when in fact move_it_to
1369 simply stopped short of CHARPOS because it reached
1370 last_visible_y. To see if that's what happened, we call
1371 move_it_to again with a slightly larger vertical limit,
1372 and see if it actually moved vertically; if it did, we
1373 didn't really reach CHARPOS, which is beyond window end. */
1374 struct it save_it
= it
;
1375 /* Why 10? because we don't know how many canonical lines
1376 will the height of the next line(s) be. So we guess. */
1377 int ten_more_lines
=
1378 10 * FRAME_LINE_HEIGHT (XFRAME (WINDOW_FRAME (w
)));
1380 move_it_to (&it
, charpos
, -1, bottom_y
+ ten_more_lines
, -1,
1381 MOVE_TO_POS
| MOVE_TO_Y
);
1382 if (it
.current_y
> top_y
)
1389 if (it_method
== GET_FROM_DISPLAY_VECTOR
)
1391 /* We stopped on the last glyph of a display vector.
1392 Try and recompute. Hack alert! */
1393 if (charpos
< 2 || top
.charpos
>= charpos
)
1394 top_x
= it
.glyph_row
->x
;
1398 start_display (&it2
, w
, top
);
1399 move_it_to (&it2
, charpos
- 1, -1, -1, -1, MOVE_TO_POS
);
1400 get_next_display_element (&it2
);
1401 PRODUCE_GLYPHS (&it2
);
1402 if (ITERATOR_AT_END_OF_LINE_P (&it2
)
1403 || it2
.current_x
> it2
.last_visible_x
)
1404 top_x
= it
.glyph_row
->x
;
1407 top_x
= it2
.current_x
;
1408 top_y
= it2
.current_y
;
1412 else if (IT_CHARPOS (it
) != charpos
)
1414 Lisp_Object cpos
= make_number (charpos
);
1415 Lisp_Object spec
= Fget_char_property (cpos
, Qdisplay
, Qnil
);
1416 Lisp_Object string
= string_from_display_spec (spec
);
1417 int newline_in_string
= 0;
1419 if (STRINGP (string
))
1421 const char *s
= SSDATA (string
);
1422 const char *e
= s
+ SBYTES (string
);
1427 newline_in_string
= 1;
1432 /* The tricky code below is needed because there's a
1433 discrepancy between move_it_to and how we set cursor
1434 when the display line ends in a newline from a
1435 display string. move_it_to will stop _after_ such
1436 display strings, whereas set_cursor_from_row
1437 conspires with cursor_row_p to place the cursor on
1438 the first glyph produced from the display string. */
1440 /* We have overshoot PT because it is covered by a
1441 display property whose value is a string. If the
1442 string includes embedded newlines, we are also in the
1443 wrong display line. Backtrack to the correct line,
1444 where the display string begins. */
1445 if (newline_in_string
)
1447 Lisp_Object startpos
, endpos
;
1448 EMACS_INT start
, end
;
1452 /* Find the first and the last buffer positions
1453 covered by the display string. */
1455 Fnext_single_char_property_change (cpos
, Qdisplay
,
1458 Fprevious_single_char_property_change (endpos
, Qdisplay
,
1460 start
= XFASTINT (startpos
);
1461 end
= XFASTINT (endpos
);
1462 /* Move to the last buffer position before the
1463 display property. */
1464 start_display (&it3
, w
, top
);
1465 move_it_to (&it3
, start
- 1, -1, -1, -1, MOVE_TO_POS
);
1466 /* Move forward one more line if the position before
1467 the display string is a newline or if it is the
1468 rightmost character on a line that is
1469 continued or word-wrapped. */
1470 if (it3
.method
== GET_FROM_BUFFER
1472 move_it_by_lines (&it3
, 1);
1473 else if (move_it_in_display_line_to (&it3
, -1,
1477 == MOVE_LINE_CONTINUED
)
1479 move_it_by_lines (&it3
, 1);
1480 /* When we are under word-wrap, the #$@%!
1481 move_it_by_lines moves 2 lines, so we need to
1483 if (it3
.line_wrap
== WORD_WRAP
)
1484 move_it_by_lines (&it3
, -1);
1487 /* Record the vertical coordinate of the display
1488 line where we wound up. */
1489 top_y
= it3
.current_y
;
1492 /* When characters are reordered for display,
1493 the character displayed to the left of the
1494 display string could be _after_ the display
1495 property in the logical order. Use the
1496 smallest vertical position of these two. */
1497 start_display (&it3
, w
, top
);
1498 move_it_to (&it3
, end
+ 1, -1, -1, -1, MOVE_TO_POS
);
1499 if (it3
.current_y
< top_y
)
1500 top_y
= it3
.current_y
;
1502 /* Move from the top of the window to the beginning
1503 of the display line where the display string
1505 start_display (&it3
, w
, top
);
1506 move_it_to (&it3
, -1, 0, top_y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
1507 /* If it3_moved stays zero after the 'while' loop
1508 below, that means we already were at a newline
1509 before the loop (e.g., the display string begins
1510 with a newline), so we don't need to (and cannot)
1511 inspect the glyphs of it3.glyph_row, because
1512 PRODUCE_GLYPHS will not produce anything for a
1513 newline, and thus it3.glyph_row stays at its
1514 stale content it got at top of the window. */
1516 /* Finally, advance the iterator until we hit the
1517 first display element whose character position is
1518 CHARPOS, or until the first newline from the
1519 display string, which signals the end of the
1521 while (get_next_display_element (&it3
))
1523 PRODUCE_GLYPHS (&it3
);
1524 if (IT_CHARPOS (it3
) == charpos
1525 || ITERATOR_AT_END_OF_LINE_P (&it3
))
1528 set_iterator_to_next (&it3
, 0);
1530 top_x
= it3
.current_x
- it3
.pixel_width
;
1531 /* Normally, we would exit the above loop because we
1532 found the display element whose character
1533 position is CHARPOS. For the contingency that we
1534 didn't, and stopped at the first newline from the
1535 display string, move back over the glyphs
1536 produced from the string, until we find the
1537 rightmost glyph not from the string. */
1539 && IT_CHARPOS (it3
) != charpos
&& EQ (it3
.object
, string
))
1541 struct glyph
*g
= it3
.glyph_row
->glyphs
[TEXT_AREA
]
1542 + it3
.glyph_row
->used
[TEXT_AREA
];
1544 while (EQ ((g
- 1)->object
, string
))
1547 top_x
-= g
->pixel_width
;
1549 eassert (g
< it3
.glyph_row
->glyphs
[TEXT_AREA
]
1550 + it3
.glyph_row
->used
[TEXT_AREA
]);
1556 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1557 *rtop
= max (0, window_top_y
- top_y
);
1558 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1559 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1560 - max (top_y
, window_top_y
)));
1566 /* We were asked to provide info about WINDOW_END. */
1568 void *it2data
= NULL
;
1570 SAVE_IT (it2
, it
, it2data
);
1571 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1572 move_it_by_lines (&it
, 1);
1573 if (charpos
< IT_CHARPOS (it
)
1574 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1577 RESTORE_IT (&it2
, &it2
, it2data
);
1578 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1580 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1581 *rtop
= max (0, -it2
.current_y
);
1582 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1583 - it
.last_visible_y
));
1584 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1586 - max (it2
.current_y
,
1587 WINDOW_HEADER_LINE_HEIGHT (w
))));
1591 bidi_unshelve_cache (it2data
, 1);
1593 bidi_unshelve_cache (itdata
, 0);
1596 set_buffer_internal_1 (old_buffer
);
1598 current_header_line_height
= current_mode_line_height
= -1;
1600 if (visible_p
&& w
->hscroll
> 0)
1602 window_hscroll_limited (w
, WINDOW_XFRAME (w
))
1603 * WINDOW_FRAME_COLUMN_WIDTH (w
);
1606 /* Debugging code. */
1608 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1609 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1611 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1618 /* Return the next character from STR. Return in *LEN the length of
1619 the character. This is like STRING_CHAR_AND_LENGTH but never
1620 returns an invalid character. If we find one, we return a `?', but
1621 with the length of the invalid character. */
1624 string_char_and_length (const unsigned char *str
, int *len
)
1628 c
= STRING_CHAR_AND_LENGTH (str
, *len
);
1629 if (!CHAR_VALID_P (c
))
1630 /* We may not change the length here because other places in Emacs
1631 don't use this function, i.e. they silently accept invalid
1640 /* Given a position POS containing a valid character and byte position
1641 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1643 static struct text_pos
1644 string_pos_nchars_ahead (struct text_pos pos
, Lisp_Object string
, ptrdiff_t nchars
)
1646 eassert (STRINGP (string
) && nchars
>= 0);
1648 if (STRING_MULTIBYTE (string
))
1650 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1655 string_char_and_length (p
, &len
);
1658 BYTEPOS (pos
) += len
;
1662 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1668 /* Value is the text position, i.e. character and byte position,
1669 for character position CHARPOS in STRING. */
1671 static struct text_pos
1672 string_pos (ptrdiff_t charpos
, Lisp_Object string
)
1674 struct text_pos pos
;
1675 eassert (STRINGP (string
));
1676 eassert (charpos
>= 0);
1677 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1682 /* Value is a text position, i.e. character and byte position, for
1683 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1684 means recognize multibyte characters. */
1686 static struct text_pos
1687 c_string_pos (ptrdiff_t charpos
, const char *s
, int multibyte_p
)
1689 struct text_pos pos
;
1691 eassert (s
!= NULL
);
1692 eassert (charpos
>= 0);
1698 SET_TEXT_POS (pos
, 0, 0);
1701 string_char_and_length ((const unsigned char *) s
, &len
);
1704 BYTEPOS (pos
) += len
;
1708 SET_TEXT_POS (pos
, charpos
, charpos
);
1714 /* Value is the number of characters in C string S. MULTIBYTE_P
1715 non-zero means recognize multibyte characters. */
1718 number_of_chars (const char *s
, int multibyte_p
)
1724 ptrdiff_t rest
= strlen (s
);
1726 const unsigned char *p
= (const unsigned char *) s
;
1728 for (nchars
= 0; rest
> 0; ++nchars
)
1730 string_char_and_length (p
, &len
);
1731 rest
-= len
, p
+= len
;
1735 nchars
= strlen (s
);
1741 /* Compute byte position NEWPOS->bytepos corresponding to
1742 NEWPOS->charpos. POS is a known position in string STRING.
1743 NEWPOS->charpos must be >= POS.charpos. */
1746 compute_string_pos (struct text_pos
*newpos
, struct text_pos pos
, Lisp_Object string
)
1748 eassert (STRINGP (string
));
1749 eassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1751 if (STRING_MULTIBYTE (string
))
1752 *newpos
= string_pos_nchars_ahead (pos
, string
,
1753 CHARPOS (*newpos
) - CHARPOS (pos
));
1755 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1759 Return an estimation of the pixel height of mode or header lines on
1760 frame F. FACE_ID specifies what line's height to estimate. */
1763 estimate_mode_line_height (struct frame
*f
, enum face_id face_id
)
1765 #ifdef HAVE_WINDOW_SYSTEM
1766 if (FRAME_WINDOW_P (f
))
1768 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1770 /* This function is called so early when Emacs starts that the face
1771 cache and mode line face are not yet initialized. */
1772 if (FRAME_FACE_CACHE (f
))
1774 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1778 height
= FONT_HEIGHT (face
->font
);
1779 if (face
->box_line_width
> 0)
1780 height
+= 2 * face
->box_line_width
;
1791 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1792 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1793 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1794 not force the value into range. */
1797 pixel_to_glyph_coords (FRAME_PTR f
, register int pix_x
, register int pix_y
,
1798 int *x
, int *y
, NativeRectangle
*bounds
, int noclip
)
1801 #ifdef HAVE_WINDOW_SYSTEM
1802 if (FRAME_WINDOW_P (f
))
1804 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1805 even for negative values. */
1807 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1809 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1811 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1812 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1815 STORE_NATIVE_RECT (*bounds
,
1816 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1817 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1818 FRAME_COLUMN_WIDTH (f
) - 1,
1819 FRAME_LINE_HEIGHT (f
) - 1);
1825 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1826 pix_x
= FRAME_TOTAL_COLS (f
);
1830 else if (pix_y
> FRAME_LINES (f
))
1831 pix_y
= FRAME_LINES (f
);
1841 /* Find the glyph under window-relative coordinates X/Y in window W.
1842 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1843 strings. Return in *HPOS and *VPOS the row and column number of
1844 the glyph found. Return in *AREA the glyph area containing X.
1845 Value is a pointer to the glyph found or null if X/Y is not on
1846 text, or we can't tell because W's current matrix is not up to
1851 x_y_to_hpos_vpos (struct window
*w
, int x
, int y
, int *hpos
, int *vpos
,
1852 int *dx
, int *dy
, int *area
)
1854 struct glyph
*glyph
, *end
;
1855 struct glyph_row
*row
= NULL
;
1858 /* Find row containing Y. Give up if some row is not enabled. */
1859 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1861 row
= MATRIX_ROW (w
->current_matrix
, i
);
1862 if (!row
->enabled_p
)
1864 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1871 /* Give up if Y is not in the window. */
1872 if (i
== w
->current_matrix
->nrows
)
1875 /* Get the glyph area containing X. */
1876 if (w
->pseudo_window_p
)
1883 if (x
< window_box_left_offset (w
, TEXT_AREA
))
1885 *area
= LEFT_MARGIN_AREA
;
1886 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
1888 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
1891 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
1895 *area
= RIGHT_MARGIN_AREA
;
1896 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
1900 /* Find glyph containing X. */
1901 glyph
= row
->glyphs
[*area
];
1902 end
= glyph
+ row
->used
[*area
];
1904 while (glyph
< end
&& x
>= glyph
->pixel_width
)
1906 x
-= glyph
->pixel_width
;
1916 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
1919 *hpos
= glyph
- row
->glyphs
[*area
];
1923 /* Convert frame-relative x/y to coordinates relative to window W.
1924 Takes pseudo-windows into account. */
1927 frame_to_window_pixel_xy (struct window
*w
, int *x
, int *y
)
1929 if (w
->pseudo_window_p
)
1931 /* A pseudo-window is always full-width, and starts at the
1932 left edge of the frame, plus a frame border. */
1933 struct frame
*f
= XFRAME (w
->frame
);
1934 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
1935 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1939 *x
-= WINDOW_LEFT_EDGE_X (w
);
1940 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1944 #ifdef HAVE_WINDOW_SYSTEM
1947 Return in RECTS[] at most N clipping rectangles for glyph string S.
1948 Return the number of stored rectangles. */
1951 get_glyph_string_clip_rects (struct glyph_string
*s
, NativeRectangle
*rects
, int n
)
1958 if (s
->row
->full_width_p
)
1960 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1961 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
1962 r
.width
= WINDOW_TOTAL_WIDTH (s
->w
);
1964 /* Unless displaying a mode or menu bar line, which are always
1965 fully visible, clip to the visible part of the row. */
1966 if (s
->w
->pseudo_window_p
)
1967 r
.height
= s
->row
->visible_height
;
1969 r
.height
= s
->height
;
1973 /* This is a text line that may be partially visible. */
1974 r
.x
= window_box_left (s
->w
, s
->area
);
1975 r
.width
= window_box_width (s
->w
, s
->area
);
1976 r
.height
= s
->row
->visible_height
;
1980 if (r
.x
< s
->clip_head
->x
)
1982 if (r
.width
>= s
->clip_head
->x
- r
.x
)
1983 r
.width
-= s
->clip_head
->x
- r
.x
;
1986 r
.x
= s
->clip_head
->x
;
1989 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
1991 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
1992 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
1997 /* If S draws overlapping rows, it's sufficient to use the top and
1998 bottom of the window for clipping because this glyph string
1999 intentionally draws over other lines. */
2000 if (s
->for_overlaps
)
2002 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2003 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
2005 /* Alas, the above simple strategy does not work for the
2006 environments with anti-aliased text: if the same text is
2007 drawn onto the same place multiple times, it gets thicker.
2008 If the overlap we are processing is for the erased cursor, we
2009 take the intersection with the rectangle of the cursor. */
2010 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
2012 XRectangle rc
, r_save
= r
;
2014 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
2015 rc
.y
= s
->w
->phys_cursor
.y
;
2016 rc
.width
= s
->w
->phys_cursor_width
;
2017 rc
.height
= s
->w
->phys_cursor_height
;
2019 x_intersect_rectangles (&r_save
, &rc
, &r
);
2024 /* Don't use S->y for clipping because it doesn't take partially
2025 visible lines into account. For example, it can be negative for
2026 partially visible lines at the top of a window. */
2027 if (!s
->row
->full_width_p
2028 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
2029 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
2031 r
.y
= max (0, s
->row
->y
);
2034 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
2036 /* If drawing the cursor, don't let glyph draw outside its
2037 advertised boundaries. Cleartype does this under some circumstances. */
2038 if (s
->hl
== DRAW_CURSOR
)
2040 struct glyph
*glyph
= s
->first_glyph
;
2045 r
.width
-= s
->x
- r
.x
;
2048 r
.width
= min (r
.width
, glyph
->pixel_width
);
2050 /* If r.y is below window bottom, ensure that we still see a cursor. */
2051 height
= min (glyph
->ascent
+ glyph
->descent
,
2052 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
2053 max_y
= window_text_bottom_y (s
->w
) - height
;
2054 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
2055 if (s
->ybase
- glyph
->ascent
> max_y
)
2062 /* Don't draw cursor glyph taller than our actual glyph. */
2063 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
2064 if (height
< r
.height
)
2066 max_y
= r
.y
+ r
.height
;
2067 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
2068 r
.height
= min (max_y
- r
.y
, height
);
2075 XRectangle r_save
= r
;
2077 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
2081 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
2082 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
2084 #ifdef CONVERT_FROM_XRECT
2085 CONVERT_FROM_XRECT (r
, *rects
);
2093 /* If we are processing overlapping and allowed to return
2094 multiple clipping rectangles, we exclude the row of the glyph
2095 string from the clipping rectangle. This is to avoid drawing
2096 the same text on the environment with anti-aliasing. */
2097 #ifdef CONVERT_FROM_XRECT
2100 XRectangle
*rs
= rects
;
2102 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
2104 if (s
->for_overlaps
& OVERLAPS_PRED
)
2107 if (r
.y
+ r
.height
> row_y
)
2110 rs
[i
].height
= row_y
- r
.y
;
2116 if (s
->for_overlaps
& OVERLAPS_SUCC
)
2119 if (r
.y
< row_y
+ s
->row
->visible_height
)
2121 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
2123 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
2124 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
2133 #ifdef CONVERT_FROM_XRECT
2134 for (i
= 0; i
< n
; i
++)
2135 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
2142 Return in *NR the clipping rectangle for glyph string S. */
2145 get_glyph_string_clip_rect (struct glyph_string
*s
, NativeRectangle
*nr
)
2147 get_glyph_string_clip_rects (s
, nr
, 1);
2152 Return the position and height of the phys cursor in window W.
2153 Set w->phys_cursor_width to width of phys cursor.
2157 get_phys_cursor_geometry (struct window
*w
, struct glyph_row
*row
,
2158 struct glyph
*glyph
, int *xp
, int *yp
, int *heightp
)
2160 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2161 int x
, y
, wd
, h
, h0
, y0
;
2163 /* Compute the width of the rectangle to draw. If on a stretch
2164 glyph, and `x-stretch-block-cursor' is nil, don't draw a
2165 rectangle as wide as the glyph, but use a canonical character
2167 wd
= glyph
->pixel_width
- 1;
2168 #if defined (HAVE_NTGUI) || defined (HAVE_NS)
2172 x
= w
->phys_cursor
.x
;
2179 if (glyph
->type
== STRETCH_GLYPH
2180 && !x_stretch_cursor_p
)
2181 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
2182 w
->phys_cursor_width
= wd
;
2184 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
2186 /* If y is below window bottom, ensure that we still see a cursor. */
2187 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
2189 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
2190 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
2192 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
2195 h
= max (h
- (y0
- y
) + 1, h0
);
2200 y0
= window_text_bottom_y (w
) - h0
;
2208 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
2209 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
2214 * Remember which glyph the mouse is over.
2218 remember_mouse_glyph (struct frame
*f
, int gx
, int gy
, NativeRectangle
*rect
)
2222 struct glyph_row
*r
, *gr
, *end_row
;
2223 enum window_part part
;
2224 enum glyph_row_area area
;
2225 int x
, y
, width
, height
;
2227 /* Try to determine frame pixel position and size of the glyph under
2228 frame pixel coordinates X/Y on frame F. */
2230 if (!f
->glyphs_initialized_p
2231 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, 0),
2234 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2235 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2239 w
= XWINDOW (window
);
2240 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
2241 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
2243 x
= window_relative_x_coord (w
, part
, gx
);
2244 y
= gy
- WINDOW_TOP_EDGE_Y (w
);
2246 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
2247 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
2249 if (w
->pseudo_window_p
)
2252 part
= ON_MODE_LINE
; /* Don't adjust margin. */
2258 case ON_LEFT_MARGIN
:
2259 area
= LEFT_MARGIN_AREA
;
2262 case ON_RIGHT_MARGIN
:
2263 area
= RIGHT_MARGIN_AREA
;
2266 case ON_HEADER_LINE
:
2268 gr
= (part
== ON_HEADER_LINE
2269 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
2270 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
2273 goto text_glyph_row_found
;
2280 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2281 if (r
->y
+ r
->height
> y
)
2287 text_glyph_row_found
:
2290 struct glyph
*g
= gr
->glyphs
[area
];
2291 struct glyph
*end
= g
+ gr
->used
[area
];
2293 height
= gr
->height
;
2294 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2295 if (gx
+ g
->pixel_width
> x
)
2300 if (g
->type
== IMAGE_GLYPH
)
2302 /* Don't remember when mouse is over image, as
2303 image may have hot-spots. */
2304 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2307 width
= g
->pixel_width
;
2311 /* Use nominal char spacing at end of line. */
2313 gx
+= (x
/ width
) * width
;
2316 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2317 gx
+= window_box_left_offset (w
, area
);
2321 /* Use nominal line height at end of window. */
2322 gx
= (x
/ width
) * width
;
2324 gy
+= (y
/ height
) * height
;
2328 case ON_LEFT_FRINGE
:
2329 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2330 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2331 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2332 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2335 case ON_RIGHT_FRINGE
:
2336 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2337 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2338 : window_box_right_offset (w
, TEXT_AREA
));
2339 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2343 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2345 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2346 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2347 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2349 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2353 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2354 if (r
->y
+ r
->height
> y
)
2361 height
= gr
->height
;
2364 /* Use nominal line height at end of window. */
2366 gy
+= (y
/ height
) * height
;
2373 /* If there is no glyph under the mouse, then we divide the screen
2374 into a grid of the smallest glyph in the frame, and use that
2377 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2378 round down even for negative values. */
2384 gx
= (gx
/ width
) * width
;
2385 gy
= (gy
/ height
) * height
;
2390 gx
+= WINDOW_LEFT_EDGE_X (w
);
2391 gy
+= WINDOW_TOP_EDGE_Y (w
);
2394 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2396 /* Visible feedback for debugging. */
2399 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2400 f
->output_data
.x
->normal_gc
,
2401 gx
, gy
, width
, height
);
2407 #endif /* HAVE_WINDOW_SYSTEM */
2410 /***********************************************************************
2411 Lisp form evaluation
2412 ***********************************************************************/
2414 /* Error handler for safe_eval and safe_call. */
2417 safe_eval_handler (Lisp_Object arg
, ptrdiff_t nargs
, Lisp_Object
*args
)
2419 add_to_log ("Error during redisplay: %S signaled %S",
2420 Flist (nargs
, args
), arg
);
2424 /* Call function FUNC with the rest of NARGS - 1 arguments
2425 following. Return the result, or nil if something went
2426 wrong. Prevent redisplay during the evaluation. */
2429 safe_call (ptrdiff_t nargs
, Lisp_Object func
, ...)
2433 if (inhibit_eval_during_redisplay
)
2439 ptrdiff_t count
= SPECPDL_INDEX ();
2440 struct gcpro gcpro1
;
2441 Lisp_Object
*args
= alloca (nargs
* word_size
);
2444 va_start (ap
, func
);
2445 for (i
= 1; i
< nargs
; i
++)
2446 args
[i
] = va_arg (ap
, Lisp_Object
);
2450 gcpro1
.nvars
= nargs
;
2451 specbind (Qinhibit_redisplay
, Qt
);
2452 /* Use Qt to ensure debugger does not run,
2453 so there is no possibility of wanting to redisplay. */
2454 val
= internal_condition_case_n (Ffuncall
, nargs
, args
, Qt
,
2457 val
= unbind_to (count
, val
);
2464 /* Call function FN with one argument ARG.
2465 Return the result, or nil if something went wrong. */
2468 safe_call1 (Lisp_Object fn
, Lisp_Object arg
)
2470 return safe_call (2, fn
, arg
);
2473 static Lisp_Object Qeval
;
2476 safe_eval (Lisp_Object sexpr
)
2478 return safe_call1 (Qeval
, sexpr
);
2481 /* Call function FN with two arguments ARG1 and ARG2.
2482 Return the result, or nil if something went wrong. */
2485 safe_call2 (Lisp_Object fn
, Lisp_Object arg1
, Lisp_Object arg2
)
2487 return safe_call (3, fn
, arg1
, arg2
);
2492 /***********************************************************************
2494 ***********************************************************************/
2498 /* Define CHECK_IT to perform sanity checks on iterators.
2499 This is for debugging. It is too slow to do unconditionally. */
2502 check_it (struct it
*it
)
2504 if (it
->method
== GET_FROM_STRING
)
2506 eassert (STRINGP (it
->string
));
2507 eassert (IT_STRING_CHARPOS (*it
) >= 0);
2511 eassert (IT_STRING_CHARPOS (*it
) < 0);
2512 if (it
->method
== GET_FROM_BUFFER
)
2514 /* Check that character and byte positions agree. */
2515 eassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2520 eassert (it
->current
.dpvec_index
>= 0);
2522 eassert (it
->current
.dpvec_index
< 0);
2525 #define CHECK_IT(IT) check_it ((IT))
2529 #define CHECK_IT(IT) (void) 0
2534 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2536 /* Check that the window end of window W is what we expect it
2537 to be---the last row in the current matrix displaying text. */
2540 check_window_end (struct window
*w
)
2542 if (!MINI_WINDOW_P (w
)
2543 && !NILP (w
->window_end_valid
))
2545 struct glyph_row
*row
;
2546 eassert ((row
= MATRIX_ROW (w
->current_matrix
,
2547 XFASTINT (w
->window_end_vpos
)),
2549 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2550 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2554 #define CHECK_WINDOW_END(W) check_window_end ((W))
2558 #define CHECK_WINDOW_END(W) (void) 0
2560 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
2564 /***********************************************************************
2565 Iterator initialization
2566 ***********************************************************************/
2568 /* Initialize IT for displaying current_buffer in window W, starting
2569 at character position CHARPOS. CHARPOS < 0 means that no buffer
2570 position is specified which is useful when the iterator is assigned
2571 a position later. BYTEPOS is the byte position corresponding to
2572 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2574 If ROW is not null, calls to produce_glyphs with IT as parameter
2575 will produce glyphs in that row.
2577 BASE_FACE_ID is the id of a base face to use. It must be one of
2578 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2579 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2580 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2582 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2583 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2584 will be initialized to use the corresponding mode line glyph row of
2585 the desired matrix of W. */
2588 init_iterator (struct it
*it
, struct window
*w
,
2589 ptrdiff_t charpos
, ptrdiff_t bytepos
,
2590 struct glyph_row
*row
, enum face_id base_face_id
)
2592 int highlight_region_p
;
2593 enum face_id remapped_base_face_id
= base_face_id
;
2595 /* Some precondition checks. */
2596 eassert (w
!= NULL
&& it
!= NULL
);
2597 eassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2600 /* If face attributes have been changed since the last redisplay,
2601 free realized faces now because they depend on face definitions
2602 that might have changed. Don't free faces while there might be
2603 desired matrices pending which reference these faces. */
2604 if (face_change_count
&& !inhibit_free_realized_faces
)
2606 face_change_count
= 0;
2607 free_all_realized_faces (Qnil
);
2610 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2611 if (! NILP (Vface_remapping_alist
))
2612 remapped_base_face_id
2613 = lookup_basic_face (XFRAME (w
->frame
), base_face_id
);
2615 /* Use one of the mode line rows of W's desired matrix if
2619 if (base_face_id
== MODE_LINE_FACE_ID
2620 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2621 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2622 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2623 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2627 memset (it
, 0, sizeof *it
);
2628 it
->current
.overlay_string_index
= -1;
2629 it
->current
.dpvec_index
= -1;
2630 it
->base_face_id
= remapped_base_face_id
;
2632 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2633 it
->paragraph_embedding
= L2R
;
2634 it
->bidi_it
.string
.lstring
= Qnil
;
2635 it
->bidi_it
.string
.s
= NULL
;
2636 it
->bidi_it
.string
.bufpos
= 0;
2638 /* The window in which we iterate over current_buffer: */
2639 XSETWINDOW (it
->window
, w
);
2641 it
->f
= XFRAME (w
->frame
);
2645 /* Extra space between lines (on window systems only). */
2646 if (base_face_id
== DEFAULT_FACE_ID
2647 && FRAME_WINDOW_P (it
->f
))
2649 if (NATNUMP (BVAR (current_buffer
, extra_line_spacing
)))
2650 it
->extra_line_spacing
= XFASTINT (BVAR (current_buffer
, extra_line_spacing
));
2651 else if (FLOATP (BVAR (current_buffer
, extra_line_spacing
)))
2652 it
->extra_line_spacing
= (XFLOAT_DATA (BVAR (current_buffer
, extra_line_spacing
))
2653 * FRAME_LINE_HEIGHT (it
->f
));
2654 else if (it
->f
->extra_line_spacing
> 0)
2655 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2656 it
->max_extra_line_spacing
= 0;
2659 /* If realized faces have been removed, e.g. because of face
2660 attribute changes of named faces, recompute them. When running
2661 in batch mode, the face cache of the initial frame is null. If
2662 we happen to get called, make a dummy face cache. */
2663 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2664 init_frame_faces (it
->f
);
2665 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2666 recompute_basic_faces (it
->f
);
2668 /* Current value of the `slice', `space-width', and 'height' properties. */
2669 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2670 it
->space_width
= Qnil
;
2671 it
->font_height
= Qnil
;
2672 it
->override_ascent
= -1;
2674 /* Are control characters displayed as `^C'? */
2675 it
->ctl_arrow_p
= !NILP (BVAR (current_buffer
, ctl_arrow
));
2677 /* -1 means everything between a CR and the following line end
2678 is invisible. >0 means lines indented more than this value are
2680 it
->selective
= (INTEGERP (BVAR (current_buffer
, selective_display
))
2682 (-1, XINT (BVAR (current_buffer
, selective_display
)),
2684 : (!NILP (BVAR (current_buffer
, selective_display
))
2686 it
->selective_display_ellipsis_p
2687 = !NILP (BVAR (current_buffer
, selective_display_ellipses
));
2689 /* Display table to use. */
2690 it
->dp
= window_display_table (w
);
2692 /* Are multibyte characters enabled in current_buffer? */
2693 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
2695 /* Non-zero if we should highlight the region. */
2697 = (!NILP (Vtransient_mark_mode
)
2698 && !NILP (BVAR (current_buffer
, mark_active
))
2699 && XMARKER (BVAR (current_buffer
, mark
))->buffer
!= 0);
2701 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2702 start and end of a visible region in window IT->w. Set both to
2703 -1 to indicate no region. */
2704 if (highlight_region_p
2705 /* Maybe highlight only in selected window. */
2706 && (/* Either show region everywhere. */
2707 highlight_nonselected_windows
2708 /* Or show region in the selected window. */
2709 || w
== XWINDOW (selected_window
)
2710 /* Or show the region if we are in the mini-buffer and W is
2711 the window the mini-buffer refers to. */
2712 || (MINI_WINDOW_P (XWINDOW (selected_window
))
2713 && WINDOWP (minibuf_selected_window
)
2714 && w
== XWINDOW (minibuf_selected_window
))))
2716 ptrdiff_t markpos
= marker_position (BVAR (current_buffer
, mark
));
2717 it
->region_beg_charpos
= min (PT
, markpos
);
2718 it
->region_end_charpos
= max (PT
, markpos
);
2721 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
2723 /* Get the position at which the redisplay_end_trigger hook should
2724 be run, if it is to be run at all. */
2725 if (MARKERP (w
->redisplay_end_trigger
)
2726 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2727 it
->redisplay_end_trigger_charpos
2728 = marker_position (w
->redisplay_end_trigger
);
2729 else if (INTEGERP (w
->redisplay_end_trigger
))
2730 it
->redisplay_end_trigger_charpos
=
2731 clip_to_bounds (PTRDIFF_MIN
, XINT (w
->redisplay_end_trigger
), PTRDIFF_MAX
);
2733 it
->tab_width
= SANE_TAB_WIDTH (current_buffer
);
2735 /* Are lines in the display truncated? */
2736 if (base_face_id
!= DEFAULT_FACE_ID
2738 || (! WINDOW_FULL_WIDTH_P (it
->w
)
2739 && ((!NILP (Vtruncate_partial_width_windows
)
2740 && !INTEGERP (Vtruncate_partial_width_windows
))
2741 || (INTEGERP (Vtruncate_partial_width_windows
)
2742 && (WINDOW_TOTAL_COLS (it
->w
)
2743 < XINT (Vtruncate_partial_width_windows
))))))
2744 it
->line_wrap
= TRUNCATE
;
2745 else if (NILP (BVAR (current_buffer
, truncate_lines
)))
2746 it
->line_wrap
= NILP (BVAR (current_buffer
, word_wrap
))
2747 ? WINDOW_WRAP
: WORD_WRAP
;
2749 it
->line_wrap
= TRUNCATE
;
2751 /* Get dimensions of truncation and continuation glyphs. These are
2752 displayed as fringe bitmaps under X, but we need them for such
2753 frames when the fringes are turned off. But leave the dimensions
2754 zero for tooltip frames, as these glyphs look ugly there and also
2755 sabotage calculations of tooltip dimensions in x-show-tip. */
2756 #ifdef HAVE_WINDOW_SYSTEM
2757 if (!(FRAME_WINDOW_P (it
->f
)
2758 && FRAMEP (tip_frame
)
2759 && it
->f
== XFRAME (tip_frame
)))
2762 if (it
->line_wrap
== TRUNCATE
)
2764 /* We will need the truncation glyph. */
2765 eassert (it
->glyph_row
== NULL
);
2766 produce_special_glyphs (it
, IT_TRUNCATION
);
2767 it
->truncation_pixel_width
= it
->pixel_width
;
2771 /* We will need the continuation glyph. */
2772 eassert (it
->glyph_row
== NULL
);
2773 produce_special_glyphs (it
, IT_CONTINUATION
);
2774 it
->continuation_pixel_width
= it
->pixel_width
;
2778 /* Reset these values to zero because the produce_special_glyphs
2779 above has changed them. */
2780 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2781 it
->phys_ascent
= it
->phys_descent
= 0;
2783 /* Set this after getting the dimensions of truncation and
2784 continuation glyphs, so that we don't produce glyphs when calling
2785 produce_special_glyphs, above. */
2786 it
->glyph_row
= row
;
2787 it
->area
= TEXT_AREA
;
2789 /* Forget any previous info about this row being reversed. */
2791 it
->glyph_row
->reversed_p
= 0;
2793 /* Get the dimensions of the display area. The display area
2794 consists of the visible window area plus a horizontally scrolled
2795 part to the left of the window. All x-values are relative to the
2796 start of this total display area. */
2797 if (base_face_id
!= DEFAULT_FACE_ID
)
2799 /* Mode lines, menu bar in terminal frames. */
2800 it
->first_visible_x
= 0;
2801 it
->last_visible_x
= WINDOW_TOTAL_WIDTH (w
);
2805 it
->first_visible_x
=
2806 window_hscroll_limited (it
->w
, it
->f
) * FRAME_COLUMN_WIDTH (it
->f
);
2807 it
->last_visible_x
= (it
->first_visible_x
2808 + window_box_width (w
, TEXT_AREA
));
2810 /* If we truncate lines, leave room for the truncation glyph(s) at
2811 the right margin. Otherwise, leave room for the continuation
2812 glyph(s). Done only if the window has no fringes. Since we
2813 don't know at this point whether there will be any R2L lines in
2814 the window, we reserve space for truncation/continuation glyphs
2815 even if only one of the fringes is absent. */
2816 if (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
2817 || (it
->bidi_p
&& WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0))
2819 if (it
->line_wrap
== TRUNCATE
)
2820 it
->last_visible_x
-= it
->truncation_pixel_width
;
2822 it
->last_visible_x
-= it
->continuation_pixel_width
;
2825 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
2826 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
2829 /* Leave room for a border glyph. */
2830 if (!FRAME_WINDOW_P (it
->f
)
2831 && !WINDOW_RIGHTMOST_P (it
->w
))
2832 it
->last_visible_x
-= 1;
2834 it
->last_visible_y
= window_text_bottom_y (w
);
2836 /* For mode lines and alike, arrange for the first glyph having a
2837 left box line if the face specifies a box. */
2838 if (base_face_id
!= DEFAULT_FACE_ID
)
2842 it
->face_id
= remapped_base_face_id
;
2844 /* If we have a boxed mode line, make the first character appear
2845 with a left box line. */
2846 face
= FACE_FROM_ID (it
->f
, remapped_base_face_id
);
2847 if (face
->box
!= FACE_NO_BOX
)
2848 it
->start_of_box_run_p
= 1;
2851 /* If a buffer position was specified, set the iterator there,
2852 getting overlays and face properties from that position. */
2853 if (charpos
>= BUF_BEG (current_buffer
))
2855 it
->end_charpos
= ZV
;
2856 IT_CHARPOS (*it
) = charpos
;
2858 /* We will rely on `reseat' to set this up properly, via
2859 handle_face_prop. */
2860 it
->face_id
= it
->base_face_id
;
2862 /* Compute byte position if not specified. */
2863 if (bytepos
< charpos
)
2864 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
2866 IT_BYTEPOS (*it
) = bytepos
;
2868 it
->start
= it
->current
;
2869 /* Do we need to reorder bidirectional text? Not if this is a
2870 unibyte buffer: by definition, none of the single-byte
2871 characters are strong R2L, so no reordering is needed. And
2872 bidi.c doesn't support unibyte buffers anyway. Also, don't
2873 reorder while we are loading loadup.el, since the tables of
2874 character properties needed for reordering are not yet
2878 && !NILP (BVAR (current_buffer
, bidi_display_reordering
))
2881 /* If we are to reorder bidirectional text, init the bidi
2885 /* Note the paragraph direction that this buffer wants to
2887 if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2889 it
->paragraph_embedding
= L2R
;
2890 else if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2892 it
->paragraph_embedding
= R2L
;
2894 it
->paragraph_embedding
= NEUTRAL_DIR
;
2895 bidi_unshelve_cache (NULL
, 0);
2896 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
2900 /* Compute faces etc. */
2901 reseat (it
, it
->current
.pos
, 1);
2908 /* Initialize IT for the display of window W with window start POS. */
2911 start_display (struct it
*it
, struct window
*w
, struct text_pos pos
)
2913 struct glyph_row
*row
;
2914 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
2916 row
= w
->desired_matrix
->rows
+ first_vpos
;
2917 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
2918 it
->first_vpos
= first_vpos
;
2920 /* Don't reseat to previous visible line start if current start
2921 position is in a string or image. */
2922 if (it
->method
== GET_FROM_BUFFER
&& it
->line_wrap
!= TRUNCATE
)
2924 int start_at_line_beg_p
;
2925 int first_y
= it
->current_y
;
2927 /* If window start is not at a line start, skip forward to POS to
2928 get the correct continuation lines width. */
2929 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
2930 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
2931 if (!start_at_line_beg_p
)
2935 reseat_at_previous_visible_line_start (it
);
2936 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
2938 new_x
= it
->current_x
+ it
->pixel_width
;
2940 /* If lines are continued, this line may end in the middle
2941 of a multi-glyph character (e.g. a control character
2942 displayed as \003, or in the middle of an overlay
2943 string). In this case move_it_to above will not have
2944 taken us to the start of the continuation line but to the
2945 end of the continued line. */
2946 if (it
->current_x
> 0
2947 && it
->line_wrap
!= TRUNCATE
/* Lines are continued. */
2948 && (/* And glyph doesn't fit on the line. */
2949 new_x
> it
->last_visible_x
2950 /* Or it fits exactly and we're on a window
2952 || (new_x
== it
->last_visible_x
2953 && FRAME_WINDOW_P (it
->f
)
2954 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
2955 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
2956 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
2958 if ((it
->current
.dpvec_index
>= 0
2959 || it
->current
.overlay_string_index
>= 0)
2960 /* If we are on a newline from a display vector or
2961 overlay string, then we are already at the end of
2962 a screen line; no need to go to the next line in
2963 that case, as this line is not really continued.
2964 (If we do go to the next line, C-e will not DTRT.) */
2967 set_iterator_to_next (it
, 1);
2968 move_it_in_display_line_to (it
, -1, -1, 0);
2971 it
->continuation_lines_width
+= it
->current_x
;
2973 /* If the character at POS is displayed via a display
2974 vector, move_it_to above stops at the final glyph of
2975 IT->dpvec. To make the caller redisplay that character
2976 again (a.k.a. start at POS), we need to reset the
2977 dpvec_index to the beginning of IT->dpvec. */
2978 else if (it
->current
.dpvec_index
>= 0)
2979 it
->current
.dpvec_index
= 0;
2981 /* We're starting a new display line, not affected by the
2982 height of the continued line, so clear the appropriate
2983 fields in the iterator structure. */
2984 it
->max_ascent
= it
->max_descent
= 0;
2985 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
2987 it
->current_y
= first_y
;
2989 it
->current_x
= it
->hpos
= 0;
2995 /* Return 1 if POS is a position in ellipses displayed for invisible
2996 text. W is the window we display, for text property lookup. */
2999 in_ellipses_for_invisible_text_p (struct display_pos
*pos
, struct window
*w
)
3001 Lisp_Object prop
, window
;
3003 ptrdiff_t charpos
= CHARPOS (pos
->pos
);
3005 /* If POS specifies a position in a display vector, this might
3006 be for an ellipsis displayed for invisible text. We won't
3007 get the iterator set up for delivering that ellipsis unless
3008 we make sure that it gets aware of the invisible text. */
3009 if (pos
->dpvec_index
>= 0
3010 && pos
->overlay_string_index
< 0
3011 && CHARPOS (pos
->string_pos
) < 0
3013 && (XSETWINDOW (window
, w
),
3014 prop
= Fget_char_property (make_number (charpos
),
3015 Qinvisible
, window
),
3016 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
3018 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
3020 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
3027 /* Initialize IT for stepping through current_buffer in window W,
3028 starting at position POS that includes overlay string and display
3029 vector/ control character translation position information. Value
3030 is zero if there are overlay strings with newlines at POS. */
3033 init_from_display_pos (struct it
*it
, struct window
*w
, struct display_pos
*pos
)
3035 ptrdiff_t charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
3036 int i
, overlay_strings_with_newlines
= 0;
3038 /* If POS specifies a position in a display vector, this might
3039 be for an ellipsis displayed for invisible text. We won't
3040 get the iterator set up for delivering that ellipsis unless
3041 we make sure that it gets aware of the invisible text. */
3042 if (in_ellipses_for_invisible_text_p (pos
, w
))
3048 /* Keep in mind: the call to reseat in init_iterator skips invisible
3049 text, so we might end up at a position different from POS. This
3050 is only a problem when POS is a row start after a newline and an
3051 overlay starts there with an after-string, and the overlay has an
3052 invisible property. Since we don't skip invisible text in
3053 display_line and elsewhere immediately after consuming the
3054 newline before the row start, such a POS will not be in a string,
3055 but the call to init_iterator below will move us to the
3057 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
3059 /* This only scans the current chunk -- it should scan all chunks.
3060 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
3061 to 16 in 22.1 to make this a lesser problem. */
3062 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
3064 const char *s
= SSDATA (it
->overlay_strings
[i
]);
3065 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
3067 while (s
< e
&& *s
!= '\n')
3072 overlay_strings_with_newlines
= 1;
3077 /* If position is within an overlay string, set up IT to the right
3079 if (pos
->overlay_string_index
>= 0)
3083 /* If the first overlay string happens to have a `display'
3084 property for an image, the iterator will be set up for that
3085 image, and we have to undo that setup first before we can
3086 correct the overlay string index. */
3087 if (it
->method
== GET_FROM_IMAGE
)
3090 /* We already have the first chunk of overlay strings in
3091 IT->overlay_strings. Load more until the one for
3092 pos->overlay_string_index is in IT->overlay_strings. */
3093 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
3095 ptrdiff_t n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
3096 it
->current
.overlay_string_index
= 0;
3099 load_overlay_strings (it
, 0);
3100 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
3104 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
3105 relative_index
= (it
->current
.overlay_string_index
3106 % OVERLAY_STRING_CHUNK_SIZE
);
3107 it
->string
= it
->overlay_strings
[relative_index
];
3108 eassert (STRINGP (it
->string
));
3109 it
->current
.string_pos
= pos
->string_pos
;
3110 it
->method
= GET_FROM_STRING
;
3111 it
->end_charpos
= SCHARS (it
->string
);
3112 /* Set up the bidi iterator for this overlay string. */
3115 it
->bidi_it
.string
.lstring
= it
->string
;
3116 it
->bidi_it
.string
.s
= NULL
;
3117 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
3118 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
3119 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
3120 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
3121 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3122 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3124 /* Synchronize the state of the bidi iterator with
3125 pos->string_pos. For any string position other than
3126 zero, this will be done automagically when we resume
3127 iteration over the string and get_visually_first_element
3128 is called. But if string_pos is zero, and the string is
3129 to be reordered for display, we need to resync manually,
3130 since it could be that the iteration state recorded in
3131 pos ended at string_pos of 0 moving backwards in string. */
3132 if (CHARPOS (pos
->string_pos
) == 0)
3134 get_visually_first_element (it
);
3135 if (IT_STRING_CHARPOS (*it
) != 0)
3138 eassert (it
->bidi_it
.charpos
< it
->bidi_it
.string
.schars
);
3139 bidi_move_to_visually_next (&it
->bidi_it
);
3140 } while (it
->bidi_it
.charpos
!= 0);
3142 eassert (IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
3143 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
);
3147 if (CHARPOS (pos
->string_pos
) >= 0)
3149 /* Recorded position is not in an overlay string, but in another
3150 string. This can only be a string from a `display' property.
3151 IT should already be filled with that string. */
3152 it
->current
.string_pos
= pos
->string_pos
;
3153 eassert (STRINGP (it
->string
));
3155 bidi_init_it (IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
),
3156 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
3159 /* Restore position in display vector translations, control
3160 character translations or ellipses. */
3161 if (pos
->dpvec_index
>= 0)
3163 if (it
->dpvec
== NULL
)
3164 get_next_display_element (it
);
3165 eassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
3166 it
->current
.dpvec_index
= pos
->dpvec_index
;
3170 return !overlay_strings_with_newlines
;
3174 /* Initialize IT for stepping through current_buffer in window W
3175 starting at ROW->start. */
3178 init_to_row_start (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3180 init_from_display_pos (it
, w
, &row
->start
);
3181 it
->start
= row
->start
;
3182 it
->continuation_lines_width
= row
->continuation_lines_width
;
3187 /* Initialize IT for stepping through current_buffer in window W
3188 starting in the line following ROW, i.e. starting at ROW->end.
3189 Value is zero if there are overlay strings with newlines at ROW's
3193 init_to_row_end (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
3197 if (init_from_display_pos (it
, w
, &row
->end
))
3199 if (row
->continued_p
)
3200 it
->continuation_lines_width
3201 = row
->continuation_lines_width
+ row
->pixel_width
;
3212 /***********************************************************************
3214 ***********************************************************************/
3216 /* Called when IT reaches IT->stop_charpos. Handle text property and
3217 overlay changes. Set IT->stop_charpos to the next position where
3221 handle_stop (struct it
*it
)
3223 enum prop_handled handled
;
3224 int handle_overlay_change_p
;
3228 it
->current
.dpvec_index
= -1;
3229 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
3230 it
->ignore_overlay_strings_at_pos_p
= 0;
3233 /* Use face of preceding text for ellipsis (if invisible) */
3234 if (it
->selective_display_ellipsis_p
)
3235 it
->saved_face_id
= it
->face_id
;
3239 handled
= HANDLED_NORMALLY
;
3241 /* Call text property handlers. */
3242 for (p
= it_props
; p
->handler
; ++p
)
3244 handled
= p
->handler (it
);
3246 if (handled
== HANDLED_RECOMPUTE_PROPS
)
3248 else if (handled
== HANDLED_RETURN
)
3250 /* We still want to show before and after strings from
3251 overlays even if the actual buffer text is replaced. */
3252 if (!handle_overlay_change_p
3254 /* Don't call get_overlay_strings_1 if we already
3255 have overlay strings loaded, because doing so
3256 will load them again and push the iterator state
3257 onto the stack one more time, which is not
3258 expected by the rest of the code that processes
3260 || (it
->current
.overlay_string_index
< 0
3261 ? !get_overlay_strings_1 (it
, 0, 0)
3265 setup_for_ellipsis (it
, 0);
3266 /* When handling a display spec, we might load an
3267 empty string. In that case, discard it here. We
3268 used to discard it in handle_single_display_spec,
3269 but that causes get_overlay_strings_1, above, to
3270 ignore overlay strings that we must check. */
3271 if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3275 else if (STRINGP (it
->string
) && !SCHARS (it
->string
))
3279 it
->ignore_overlay_strings_at_pos_p
= 1;
3280 it
->string_from_display_prop_p
= 0;
3281 it
->from_disp_prop_p
= 0;
3282 handle_overlay_change_p
= 0;
3284 handled
= HANDLED_RECOMPUTE_PROPS
;
3287 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
3288 handle_overlay_change_p
= 0;
3291 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
3293 /* Don't check for overlay strings below when set to deliver
3294 characters from a display vector. */
3295 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
3296 handle_overlay_change_p
= 0;
3298 /* Handle overlay changes.
3299 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
3300 if it finds overlays. */
3301 if (handle_overlay_change_p
)
3302 handled
= handle_overlay_change (it
);
3307 setup_for_ellipsis (it
, 0);
3311 while (handled
== HANDLED_RECOMPUTE_PROPS
);
3313 /* Determine where to stop next. */
3314 if (handled
== HANDLED_NORMALLY
)
3315 compute_stop_pos (it
);
3319 /* Compute IT->stop_charpos from text property and overlay change
3320 information for IT's current position. */
3323 compute_stop_pos (struct it
*it
)
3325 register INTERVAL iv
, next_iv
;
3326 Lisp_Object object
, limit
, position
;
3327 ptrdiff_t charpos
, bytepos
;
3329 if (STRINGP (it
->string
))
3331 /* Strings are usually short, so don't limit the search for
3333 it
->stop_charpos
= it
->end_charpos
;
3334 object
= it
->string
;
3336 charpos
= IT_STRING_CHARPOS (*it
);
3337 bytepos
= IT_STRING_BYTEPOS (*it
);
3343 /* If end_charpos is out of range for some reason, such as a
3344 misbehaving display function, rationalize it (Bug#5984). */
3345 if (it
->end_charpos
> ZV
)
3346 it
->end_charpos
= ZV
;
3347 it
->stop_charpos
= it
->end_charpos
;
3349 /* If next overlay change is in front of the current stop pos
3350 (which is IT->end_charpos), stop there. Note: value of
3351 next_overlay_change is point-max if no overlay change
3353 charpos
= IT_CHARPOS (*it
);
3354 bytepos
= IT_BYTEPOS (*it
);
3355 pos
= next_overlay_change (charpos
);
3356 if (pos
< it
->stop_charpos
)
3357 it
->stop_charpos
= pos
;
3359 /* If showing the region, we have to stop at the region
3360 start or end because the face might change there. */
3361 if (it
->region_beg_charpos
> 0)
3363 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
3364 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
3365 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
3366 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
3369 /* Set up variables for computing the stop position from text
3370 property changes. */
3371 XSETBUFFER (object
, current_buffer
);
3372 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
3375 /* Get the interval containing IT's position. Value is a null
3376 interval if there isn't such an interval. */
3377 position
= make_number (charpos
);
3378 iv
= validate_interval_range (object
, &position
, &position
, 0);
3381 Lisp_Object values_here
[LAST_PROP_IDX
];
3384 /* Get properties here. */
3385 for (p
= it_props
; p
->handler
; ++p
)
3386 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3388 /* Look for an interval following iv that has different
3390 for (next_iv
= next_interval (iv
);
3393 || XFASTINT (limit
) > next_iv
->position
));
3394 next_iv
= next_interval (next_iv
))
3396 for (p
= it_props
; p
->handler
; ++p
)
3398 Lisp_Object new_value
;
3400 new_value
= textget (next_iv
->plist
, *p
->name
);
3401 if (!EQ (values_here
[p
->idx
], new_value
))
3411 if (INTEGERP (limit
)
3412 && next_iv
->position
>= XFASTINT (limit
))
3413 /* No text property change up to limit. */
3414 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3416 /* Text properties change in next_iv. */
3417 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3421 if (it
->cmp_it
.id
< 0)
3423 ptrdiff_t stoppos
= it
->end_charpos
;
3425 if (it
->bidi_p
&& it
->bidi_it
.scan_dir
< 0)
3427 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
,
3428 stoppos
, it
->string
);
3431 eassert (STRINGP (it
->string
)
3432 || (it
->stop_charpos
>= BEGV
3433 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3437 /* Return the position of the next overlay change after POS in
3438 current_buffer. Value is point-max if no overlay change
3439 follows. This is like `next-overlay-change' but doesn't use
3443 next_overlay_change (ptrdiff_t pos
)
3445 ptrdiff_t i
, noverlays
;
3447 Lisp_Object
*overlays
;
3449 /* Get all overlays at the given position. */
3450 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3452 /* If any of these overlays ends before endpos,
3453 use its ending point instead. */
3454 for (i
= 0; i
< noverlays
; ++i
)
3459 oend
= OVERLAY_END (overlays
[i
]);
3460 oendpos
= OVERLAY_POSITION (oend
);
3461 endpos
= min (endpos
, oendpos
);
3467 /* How many characters forward to search for a display property or
3468 display string. Searching too far forward makes the bidi display
3469 sluggish, especially in small windows. */
3470 #define MAX_DISP_SCAN 250
3472 /* Return the character position of a display string at or after
3473 position specified by POSITION. If no display string exists at or
3474 after POSITION, return ZV. A display string is either an overlay
3475 with `display' property whose value is a string, or a `display'
3476 text property whose value is a string. STRING is data about the
3477 string to iterate; if STRING->lstring is nil, we are iterating a
3478 buffer. FRAME_WINDOW_P is non-zero when we are displaying a window
3479 on a GUI frame. DISP_PROP is set to zero if we searched
3480 MAX_DISP_SCAN characters forward without finding any display
3481 strings, non-zero otherwise. It is set to 2 if the display string
3482 uses any kind of `(space ...)' spec that will produce a stretch of
3483 white space in the text area. */
3485 compute_display_string_pos (struct text_pos
*position
,
3486 struct bidi_string_data
*string
,
3487 int frame_window_p
, int *disp_prop
)
3489 /* OBJECT = nil means current buffer. */
3490 Lisp_Object object
=
3491 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3492 Lisp_Object pos
, spec
, limpos
;
3493 int string_p
= (string
&& (STRINGP (string
->lstring
) || string
->s
));
3494 ptrdiff_t eob
= string_p
? string
->schars
: ZV
;
3495 ptrdiff_t begb
= string_p
? 0 : BEGV
;
3496 ptrdiff_t bufpos
, charpos
= CHARPOS (*position
);
3498 (charpos
< eob
- MAX_DISP_SCAN
) ? charpos
+ MAX_DISP_SCAN
: eob
;
3499 struct text_pos tpos
;
3505 /* We don't support display properties whose values are strings
3506 that have display string properties. */
3507 || string
->from_disp_str
3508 /* C strings cannot have display properties. */
3509 || (string
->s
&& !STRINGP (object
)))
3515 /* If the character at CHARPOS is where the display string begins,
3517 pos
= make_number (charpos
);
3518 if (STRINGP (object
))
3519 bufpos
= string
->bufpos
;
3523 if (!NILP (spec
= Fget_char_property (pos
, Qdisplay
, object
))
3525 || !EQ (Fget_char_property (make_number (charpos
- 1), Qdisplay
,
3528 && (rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
, bufpos
,
3536 /* Look forward for the first character with a `display' property
3537 that will replace the underlying text when displayed. */
3538 limpos
= make_number (lim
);
3540 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, limpos
);
3541 CHARPOS (tpos
) = XFASTINT (pos
);
3542 if (CHARPOS (tpos
) >= lim
)
3547 if (STRINGP (object
))
3548 BYTEPOS (tpos
) = string_char_to_byte (object
, CHARPOS (tpos
));
3550 BYTEPOS (tpos
) = CHAR_TO_BYTE (CHARPOS (tpos
));
3551 spec
= Fget_char_property (pos
, Qdisplay
, object
);
3552 if (!STRINGP (object
))
3553 bufpos
= CHARPOS (tpos
);
3554 } while (NILP (spec
)
3555 || !(rv
= handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
,
3556 bufpos
, frame_window_p
)));
3560 return CHARPOS (tpos
);
3563 /* Return the character position of the end of the display string that
3564 started at CHARPOS. If there's no display string at CHARPOS,
3565 return -1. A display string is either an overlay with `display'
3566 property whose value is a string or a `display' text property whose
3567 value is a string. */
3569 compute_display_string_end (ptrdiff_t charpos
, struct bidi_string_data
*string
)
3571 /* OBJECT = nil means current buffer. */
3572 Lisp_Object object
=
3573 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3574 Lisp_Object pos
= make_number (charpos
);
3576 (STRINGP (object
) || (string
&& string
->s
)) ? string
->schars
: ZV
;
3578 if (charpos
>= eob
|| (string
->s
&& !STRINGP (object
)))
3581 /* It could happen that the display property or overlay was removed
3582 since we found it in compute_display_string_pos above. One way
3583 this can happen is if JIT font-lock was called (through
3584 handle_fontified_prop), and jit-lock-functions remove text
3585 properties or overlays from the portion of buffer that includes
3586 CHARPOS. Muse mode is known to do that, for example. In this
3587 case, we return -1 to the caller, to signal that no display
3588 string is actually present at CHARPOS. See bidi_fetch_char for
3589 how this is handled.
3591 An alternative would be to never look for display properties past
3592 it->stop_charpos. But neither compute_display_string_pos nor
3593 bidi_fetch_char that calls it know or care where the next
3595 if (NILP (Fget_char_property (pos
, Qdisplay
, object
)))
3598 /* Look forward for the first character where the `display' property
3600 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3602 return XFASTINT (pos
);
3607 /***********************************************************************
3609 ***********************************************************************/
3611 /* Handle changes in the `fontified' property of the current buffer by
3612 calling hook functions from Qfontification_functions to fontify
3615 static enum prop_handled
3616 handle_fontified_prop (struct it
*it
)
3618 Lisp_Object prop
, pos
;
3619 enum prop_handled handled
= HANDLED_NORMALLY
;
3621 if (!NILP (Vmemory_full
))
3624 /* Get the value of the `fontified' property at IT's current buffer
3625 position. (The `fontified' property doesn't have a special
3626 meaning in strings.) If the value is nil, call functions from
3627 Qfontification_functions. */
3628 if (!STRINGP (it
->string
)
3630 && !NILP (Vfontification_functions
)
3631 && !NILP (Vrun_hooks
)
3632 && (pos
= make_number (IT_CHARPOS (*it
)),
3633 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3634 /* Ignore the special cased nil value always present at EOB since
3635 no amount of fontifying will be able to change it. */
3636 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3638 ptrdiff_t count
= SPECPDL_INDEX ();
3640 struct buffer
*obuf
= current_buffer
;
3641 int begv
= BEGV
, zv
= ZV
;
3642 int old_clip_changed
= current_buffer
->clip_changed
;
3644 val
= Vfontification_functions
;
3645 specbind (Qfontification_functions
, Qnil
);
3647 eassert (it
->end_charpos
== ZV
);
3649 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3650 safe_call1 (val
, pos
);
3653 Lisp_Object fns
, fn
;
3654 struct gcpro gcpro1
, gcpro2
;
3659 for (; CONSP (val
); val
= XCDR (val
))
3665 /* A value of t indicates this hook has a local
3666 binding; it means to run the global binding too.
3667 In a global value, t should not occur. If it
3668 does, we must ignore it to avoid an endless
3670 for (fns
= Fdefault_value (Qfontification_functions
);
3676 safe_call1 (fn
, pos
);
3680 safe_call1 (fn
, pos
);
3686 unbind_to (count
, Qnil
);
3688 /* Fontification functions routinely call `save-restriction'.
3689 Normally, this tags clip_changed, which can confuse redisplay
3690 (see discussion in Bug#6671). Since we don't perform any
3691 special handling of fontification changes in the case where
3692 `save-restriction' isn't called, there's no point doing so in
3693 this case either. So, if the buffer's restrictions are
3694 actually left unchanged, reset clip_changed. */
3695 if (obuf
== current_buffer
)
3697 if (begv
== BEGV
&& zv
== ZV
)
3698 current_buffer
->clip_changed
= old_clip_changed
;
3700 /* There isn't much we can reasonably do to protect against
3701 misbehaving fontification, but here's a fig leaf. */
3702 else if (BUFFER_LIVE_P (obuf
))
3703 set_buffer_internal_1 (obuf
);
3705 /* The fontification code may have added/removed text.
3706 It could do even a lot worse, but let's at least protect against
3707 the most obvious case where only the text past `pos' gets changed',
3708 as is/was done in grep.el where some escapes sequences are turned
3709 into face properties (bug#7876). */
3710 it
->end_charpos
= ZV
;
3712 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3713 something. This avoids an endless loop if they failed to
3714 fontify the text for which reason ever. */
3715 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3716 handled
= HANDLED_RECOMPUTE_PROPS
;
3724 /***********************************************************************
3726 ***********************************************************************/
3728 /* Set up iterator IT from face properties at its current position.
3729 Called from handle_stop. */
3731 static enum prop_handled
3732 handle_face_prop (struct it
*it
)
3735 ptrdiff_t next_stop
;
3737 if (!STRINGP (it
->string
))
3740 = face_at_buffer_position (it
->w
,
3742 it
->region_beg_charpos
,
3743 it
->region_end_charpos
,
3746 + TEXT_PROP_DISTANCE_LIMIT
),
3747 0, it
->base_face_id
);
3749 /* Is this a start of a run of characters with box face?
3750 Caveat: this can be called for a freshly initialized
3751 iterator; face_id is -1 in this case. We know that the new
3752 face will not change until limit, i.e. if the new face has a
3753 box, all characters up to limit will have one. But, as
3754 usual, we don't know whether limit is really the end. */
3755 if (new_face_id
!= it
->face_id
)
3757 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3759 /* If new face has a box but old face has not, this is
3760 the start of a run of characters with box, i.e. it has
3761 a shadow on the left side. The value of face_id of the
3762 iterator will be -1 if this is the initial call that gets
3763 the face. In this case, we have to look in front of IT's
3764 position and see whether there is a face != new_face_id. */
3765 it
->start_of_box_run_p
3766 = (new_face
->box
!= FACE_NO_BOX
3767 && (it
->face_id
>= 0
3768 || IT_CHARPOS (*it
) == BEG
3769 || new_face_id
!= face_before_it_pos (it
)));
3770 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3778 Lisp_Object from_overlay
3779 = (it
->current
.overlay_string_index
>= 0
3780 ? it
->string_overlays
[it
->current
.overlay_string_index
3781 % OVERLAY_STRING_CHUNK_SIZE
]
3784 /* See if we got to this string directly or indirectly from
3785 an overlay property. That includes the before-string or
3786 after-string of an overlay, strings in display properties
3787 provided by an overlay, their text properties, etc.
3789 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3790 if (! NILP (from_overlay
))
3791 for (i
= it
->sp
- 1; i
>= 0; i
--)
3793 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3795 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
3796 % OVERLAY_STRING_CHUNK_SIZE
];
3797 else if (! NILP (it
->stack
[i
].from_overlay
))
3798 from_overlay
= it
->stack
[i
].from_overlay
;
3800 if (!NILP (from_overlay
))
3804 if (! NILP (from_overlay
))
3806 bufpos
= IT_CHARPOS (*it
);
3807 /* For a string from an overlay, the base face depends
3808 only on text properties and ignores overlays. */
3810 = face_for_overlay_string (it
->w
,
3812 it
->region_beg_charpos
,
3813 it
->region_end_charpos
,
3816 + TEXT_PROP_DISTANCE_LIMIT
),
3824 /* For strings from a `display' property, use the face at
3825 IT's current buffer position as the base face to merge
3826 with, so that overlay strings appear in the same face as
3827 surrounding text, unless they specify their own
3829 base_face_id
= it
->string_from_prefix_prop_p
3831 : underlying_face_id (it
);
3834 new_face_id
= face_at_string_position (it
->w
,
3836 IT_STRING_CHARPOS (*it
),
3838 it
->region_beg_charpos
,
3839 it
->region_end_charpos
,
3843 /* Is this a start of a run of characters with box? Caveat:
3844 this can be called for a freshly allocated iterator; face_id
3845 is -1 is this case. We know that the new face will not
3846 change until the next check pos, i.e. if the new face has a
3847 box, all characters up to that position will have a
3848 box. But, as usual, we don't know whether that position
3849 is really the end. */
3850 if (new_face_id
!= it
->face_id
)
3852 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3853 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3855 /* If new face has a box but old face hasn't, this is the
3856 start of a run of characters with box, i.e. it has a
3857 shadow on the left side. */
3858 it
->start_of_box_run_p
3859 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
3860 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3864 it
->face_id
= new_face_id
;
3865 return HANDLED_NORMALLY
;
3869 /* Return the ID of the face ``underlying'' IT's current position,
3870 which is in a string. If the iterator is associated with a
3871 buffer, return the face at IT's current buffer position.
3872 Otherwise, use the iterator's base_face_id. */
3875 underlying_face_id (struct it
*it
)
3877 int face_id
= it
->base_face_id
, i
;
3879 eassert (STRINGP (it
->string
));
3881 for (i
= it
->sp
- 1; i
>= 0; --i
)
3882 if (NILP (it
->stack
[i
].string
))
3883 face_id
= it
->stack
[i
].face_id
;
3889 /* Compute the face one character before or after the current position
3890 of IT, in the visual order. BEFORE_P non-zero means get the face
3891 in front (to the left in L2R paragraphs, to the right in R2L
3892 paragraphs) of IT's screen position. Value is the ID of the face. */
3895 face_before_or_after_it_pos (struct it
*it
, int before_p
)
3898 ptrdiff_t next_check_charpos
;
3900 void *it_copy_data
= NULL
;
3902 eassert (it
->s
== NULL
);
3904 if (STRINGP (it
->string
))
3906 ptrdiff_t bufpos
, charpos
;
3909 /* No face change past the end of the string (for the case
3910 we are padding with spaces). No face change before the
3912 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
3913 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
3918 /* Set charpos to the position before or after IT's current
3919 position, in the logical order, which in the non-bidi
3920 case is the same as the visual order. */
3922 charpos
= IT_STRING_CHARPOS (*it
) - 1;
3923 else if (it
->what
== IT_COMPOSITION
)
3924 /* For composition, we must check the character after the
3926 charpos
= IT_STRING_CHARPOS (*it
) + it
->cmp_it
.nchars
;
3928 charpos
= IT_STRING_CHARPOS (*it
) + 1;
3934 /* With bidi iteration, the character before the current
3935 in the visual order cannot be found by simple
3936 iteration, because "reverse" reordering is not
3937 supported. Instead, we need to use the move_it_*
3938 family of functions. */
3939 /* Ignore face changes before the first visible
3940 character on this display line. */
3941 if (it
->current_x
<= it
->first_visible_x
)
3943 SAVE_IT (it_copy
, *it
, it_copy_data
);
3944 /* Implementation note: Since move_it_in_display_line
3945 works in the iterator geometry, and thinks the first
3946 character is always the leftmost, even in R2L lines,
3947 we don't need to distinguish between the R2L and L2R
3949 move_it_in_display_line (&it_copy
, SCHARS (it_copy
.string
),
3950 it_copy
.current_x
- 1, MOVE_TO_X
);
3951 charpos
= IT_STRING_CHARPOS (it_copy
);
3952 RESTORE_IT (it
, it
, it_copy_data
);
3956 /* Set charpos to the string position of the character
3957 that comes after IT's current position in the visual
3959 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
3963 bidi_move_to_visually_next (&it_copy
.bidi_it
);
3965 charpos
= it_copy
.bidi_it
.charpos
;
3968 eassert (0 <= charpos
&& charpos
<= SCHARS (it
->string
));
3970 if (it
->current
.overlay_string_index
>= 0)
3971 bufpos
= IT_CHARPOS (*it
);
3975 base_face_id
= underlying_face_id (it
);
3977 /* Get the face for ASCII, or unibyte. */
3978 face_id
= face_at_string_position (it
->w
,
3982 it
->region_beg_charpos
,
3983 it
->region_end_charpos
,
3984 &next_check_charpos
,
3987 /* Correct the face for charsets different from ASCII. Do it
3988 for the multibyte case only. The face returned above is
3989 suitable for unibyte text if IT->string is unibyte. */
3990 if (STRING_MULTIBYTE (it
->string
))
3992 struct text_pos pos1
= string_pos (charpos
, it
->string
);
3993 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos1
);
3995 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3997 c
= string_char_and_length (p
, &len
);
3998 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, charpos
, it
->string
);
4003 struct text_pos pos
;
4005 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
4006 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
4009 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
4010 pos
= it
->current
.pos
;
4015 DEC_TEXT_POS (pos
, it
->multibyte_p
);
4018 if (it
->what
== IT_COMPOSITION
)
4020 /* For composition, we must check the position after
4022 pos
.charpos
+= it
->cmp_it
.nchars
;
4023 pos
.bytepos
+= it
->len
;
4026 INC_TEXT_POS (pos
, it
->multibyte_p
);
4033 /* With bidi iteration, the character before the current
4034 in the visual order cannot be found by simple
4035 iteration, because "reverse" reordering is not
4036 supported. Instead, we need to use the move_it_*
4037 family of functions. */
4038 /* Ignore face changes before the first visible
4039 character on this display line. */
4040 if (it
->current_x
<= it
->first_visible_x
)
4042 SAVE_IT (it_copy
, *it
, it_copy_data
);
4043 /* Implementation note: Since move_it_in_display_line
4044 works in the iterator geometry, and thinks the first
4045 character is always the leftmost, even in R2L lines,
4046 we don't need to distinguish between the R2L and L2R
4048 move_it_in_display_line (&it_copy
, ZV
,
4049 it_copy
.current_x
- 1, MOVE_TO_X
);
4050 pos
= it_copy
.current
.pos
;
4051 RESTORE_IT (it
, it
, it_copy_data
);
4055 /* Set charpos to the buffer position of the character
4056 that comes after IT's current position in the visual
4058 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
4062 bidi_move_to_visually_next (&it_copy
.bidi_it
);
4065 it_copy
.bidi_it
.charpos
, it_copy
.bidi_it
.bytepos
);
4068 eassert (BEGV
<= CHARPOS (pos
) && CHARPOS (pos
) <= ZV
);
4070 /* Determine face for CHARSET_ASCII, or unibyte. */
4071 face_id
= face_at_buffer_position (it
->w
,
4073 it
->region_beg_charpos
,
4074 it
->region_end_charpos
,
4075 &next_check_charpos
,
4078 /* Correct the face for charsets different from ASCII. Do it
4079 for the multibyte case only. The face returned above is
4080 suitable for unibyte text if current_buffer is unibyte. */
4081 if (it
->multibyte_p
)
4083 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
4084 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
4085 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
4094 /***********************************************************************
4096 ***********************************************************************/
4098 /* Set up iterator IT from invisible properties at its current
4099 position. Called from handle_stop. */
4101 static enum prop_handled
4102 handle_invisible_prop (struct it
*it
)
4104 enum prop_handled handled
= HANDLED_NORMALLY
;
4108 if (STRINGP (it
->string
))
4110 Lisp_Object end_charpos
, limit
, charpos
;
4112 /* Get the value of the invisible text property at the
4113 current position. Value will be nil if there is no such
4115 charpos
= make_number (IT_STRING_CHARPOS (*it
));
4116 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
4117 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4119 if (invis_p
&& IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
4121 /* Record whether we have to display an ellipsis for the
4123 int display_ellipsis_p
= (invis_p
== 2);
4124 ptrdiff_t len
, endpos
;
4126 handled
= HANDLED_RECOMPUTE_PROPS
;
4128 /* Get the position at which the next visible text can be
4129 found in IT->string, if any. */
4130 endpos
= len
= SCHARS (it
->string
);
4131 XSETINT (limit
, len
);
4134 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
4136 if (INTEGERP (end_charpos
))
4138 endpos
= XFASTINT (end_charpos
);
4139 prop
= Fget_text_property (end_charpos
, Qinvisible
, it
->string
);
4140 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4142 display_ellipsis_p
= 1;
4145 while (invis_p
&& endpos
< len
);
4147 if (display_ellipsis_p
)
4152 /* Text at END_CHARPOS is visible. Move IT there. */
4153 struct text_pos old
;
4156 old
= it
->current
.string_pos
;
4157 oldpos
= CHARPOS (old
);
4160 if (it
->bidi_it
.first_elt
4161 && it
->bidi_it
.charpos
< SCHARS (it
->string
))
4162 bidi_paragraph_init (it
->paragraph_embedding
,
4164 /* Bidi-iterate out of the invisible text. */
4167 bidi_move_to_visually_next (&it
->bidi_it
);
4169 while (oldpos
<= it
->bidi_it
.charpos
4170 && it
->bidi_it
.charpos
< endpos
);
4172 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4173 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4174 if (IT_CHARPOS (*it
) >= endpos
)
4175 it
->prev_stop
= endpos
;
4179 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
4180 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
4185 /* The rest of the string is invisible. If this is an
4186 overlay string, proceed with the next overlay string
4187 or whatever comes and return a character from there. */
4188 if (it
->current
.overlay_string_index
>= 0
4189 && !display_ellipsis_p
)
4191 next_overlay_string (it
);
4192 /* Don't check for overlay strings when we just
4193 finished processing them. */
4194 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
4198 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
4199 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
4206 ptrdiff_t newpos
, next_stop
, start_charpos
, tem
;
4207 Lisp_Object pos
, overlay
;
4209 /* First of all, is there invisible text at this position? */
4210 tem
= start_charpos
= IT_CHARPOS (*it
);
4211 pos
= make_number (tem
);
4212 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
4214 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4216 /* If we are on invisible text, skip over it. */
4217 if (invis_p
&& start_charpos
< it
->end_charpos
)
4219 /* Record whether we have to display an ellipsis for the
4221 int display_ellipsis_p
= invis_p
== 2;
4223 handled
= HANDLED_RECOMPUTE_PROPS
;
4225 /* Loop skipping over invisible text. The loop is left at
4226 ZV or with IT on the first char being visible again. */
4229 /* Try to skip some invisible text. Return value is the
4230 position reached which can be equal to where we start
4231 if there is nothing invisible there. This skips both
4232 over invisible text properties and overlays with
4233 invisible property. */
4234 newpos
= skip_invisible (tem
, &next_stop
, ZV
, it
->window
);
4236 /* If we skipped nothing at all we weren't at invisible
4237 text in the first place. If everything to the end of
4238 the buffer was skipped, end the loop. */
4239 if (newpos
== tem
|| newpos
>= ZV
)
4243 /* We skipped some characters but not necessarily
4244 all there are. Check if we ended up on visible
4245 text. Fget_char_property returns the property of
4246 the char before the given position, i.e. if we
4247 get invis_p = 0, this means that the char at
4248 newpos is visible. */
4249 pos
= make_number (newpos
);
4250 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
4251 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
4254 /* If we ended up on invisible text, proceed to
4255 skip starting with next_stop. */
4259 /* If there are adjacent invisible texts, don't lose the
4260 second one's ellipsis. */
4262 display_ellipsis_p
= 1;
4266 /* The position newpos is now either ZV or on visible text. */
4269 ptrdiff_t bpos
= CHAR_TO_BYTE (newpos
);
4271 bpos
== ZV_BYTE
|| FETCH_BYTE (bpos
) == '\n';
4273 newpos
<= BEGV
|| FETCH_BYTE (bpos
- 1) == '\n';
4275 /* If the invisible text ends on a newline or on a
4276 character after a newline, we can avoid the costly,
4277 character by character, bidi iteration to NEWPOS, and
4278 instead simply reseat the iterator there. That's
4279 because all bidi reordering information is tossed at
4280 the newline. This is a big win for modes that hide
4281 complete lines, like Outline, Org, etc. */
4282 if (on_newline
|| after_newline
)
4284 struct text_pos tpos
;
4285 bidi_dir_t pdir
= it
->bidi_it
.paragraph_dir
;
4287 SET_TEXT_POS (tpos
, newpos
, bpos
);
4288 reseat_1 (it
, tpos
, 0);
4289 /* If we reseat on a newline/ZV, we need to prep the
4290 bidi iterator for advancing to the next character
4291 after the newline/EOB, keeping the current paragraph
4292 direction (so that PRODUCE_GLYPHS does TRT wrt
4293 prepending/appending glyphs to a glyph row). */
4296 it
->bidi_it
.first_elt
= 0;
4297 it
->bidi_it
.paragraph_dir
= pdir
;
4298 it
->bidi_it
.ch
= (bpos
== ZV_BYTE
) ? -1 : '\n';
4299 it
->bidi_it
.nchars
= 1;
4300 it
->bidi_it
.ch_len
= 1;
4303 else /* Must use the slow method. */
4305 /* With bidi iteration, the region of invisible text
4306 could start and/or end in the middle of a
4307 non-base embedding level. Therefore, we need to
4308 skip invisible text using the bidi iterator,
4309 starting at IT's current position, until we find
4310 ourselves outside of the invisible text.
4311 Skipping invisible text _after_ bidi iteration
4312 avoids affecting the visual order of the
4313 displayed text when invisible properties are
4314 added or removed. */
4315 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
4317 /* If we were `reseat'ed to a new paragraph,
4318 determine the paragraph base direction. We
4319 need to do it now because
4320 next_element_from_buffer may not have a
4321 chance to do it, if we are going to skip any
4322 text at the beginning, which resets the
4324 bidi_paragraph_init (it
->paragraph_embedding
,
4329 bidi_move_to_visually_next (&it
->bidi_it
);
4331 while (it
->stop_charpos
<= it
->bidi_it
.charpos
4332 && it
->bidi_it
.charpos
< newpos
);
4333 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
4334 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
4335 /* If we overstepped NEWPOS, record its position in
4336 the iterator, so that we skip invisible text if
4337 later the bidi iteration lands us in the
4338 invisible region again. */
4339 if (IT_CHARPOS (*it
) >= newpos
)
4340 it
->prev_stop
= newpos
;
4345 IT_CHARPOS (*it
) = newpos
;
4346 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
4349 /* If there are before-strings at the start of invisible
4350 text, and the text is invisible because of a text
4351 property, arrange to show before-strings because 20.x did
4352 it that way. (If the text is invisible because of an
4353 overlay property instead of a text property, this is
4354 already handled in the overlay code.) */
4356 && get_overlay_strings (it
, it
->stop_charpos
))
4358 handled
= HANDLED_RECOMPUTE_PROPS
;
4359 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
4361 else if (display_ellipsis_p
)
4363 /* Make sure that the glyphs of the ellipsis will get
4364 correct `charpos' values. If we would not update
4365 it->position here, the glyphs would belong to the
4366 last visible character _before_ the invisible
4367 text, which confuses `set_cursor_from_row'.
4369 We use the last invisible position instead of the
4370 first because this way the cursor is always drawn on
4371 the first "." of the ellipsis, whenever PT is inside
4372 the invisible text. Otherwise the cursor would be
4373 placed _after_ the ellipsis when the point is after the
4374 first invisible character. */
4375 if (!STRINGP (it
->object
))
4377 it
->position
.charpos
= newpos
- 1;
4378 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
4381 /* Let the ellipsis display before
4382 considering any properties of the following char.
4383 Fixes jasonr@gnu.org 01 Oct 07 bug. */
4384 handled
= HANDLED_RETURN
;
4393 /* Make iterator IT return `...' next.
4394 Replaces LEN characters from buffer. */
4397 setup_for_ellipsis (struct it
*it
, int len
)
4399 /* Use the display table definition for `...'. Invalid glyphs
4400 will be handled by the method returning elements from dpvec. */
4401 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4403 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4404 it
->dpvec
= v
->contents
;
4405 it
->dpend
= v
->contents
+ v
->header
.size
;
4409 /* Default `...'. */
4410 it
->dpvec
= default_invis_vector
;
4411 it
->dpend
= default_invis_vector
+ 3;
4414 it
->dpvec_char_len
= len
;
4415 it
->current
.dpvec_index
= 0;
4416 it
->dpvec_face_id
= -1;
4418 /* Remember the current face id in case glyphs specify faces.
4419 IT's face is restored in set_iterator_to_next.
4420 saved_face_id was set to preceding char's face in handle_stop. */
4421 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
4422 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
4424 it
->method
= GET_FROM_DISPLAY_VECTOR
;
4430 /***********************************************************************
4432 ***********************************************************************/
4434 /* Set up iterator IT from `display' property at its current position.
4435 Called from handle_stop.
4436 We return HANDLED_RETURN if some part of the display property
4437 overrides the display of the buffer text itself.
4438 Otherwise we return HANDLED_NORMALLY. */
4440 static enum prop_handled
4441 handle_display_prop (struct it
*it
)
4443 Lisp_Object propval
, object
, overlay
;
4444 struct text_pos
*position
;
4446 /* Nonzero if some property replaces the display of the text itself. */
4447 int display_replaced_p
= 0;
4449 if (STRINGP (it
->string
))
4451 object
= it
->string
;
4452 position
= &it
->current
.string_pos
;
4453 bufpos
= CHARPOS (it
->current
.pos
);
4457 XSETWINDOW (object
, it
->w
);
4458 position
= &it
->current
.pos
;
4459 bufpos
= CHARPOS (*position
);
4462 /* Reset those iterator values set from display property values. */
4463 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
4464 it
->space_width
= Qnil
;
4465 it
->font_height
= Qnil
;
4468 /* We don't support recursive `display' properties, i.e. string
4469 values that have a string `display' property, that have a string
4470 `display' property etc. */
4471 if (!it
->string_from_display_prop_p
)
4472 it
->area
= TEXT_AREA
;
4474 propval
= get_char_property_and_overlay (make_number (position
->charpos
),
4475 Qdisplay
, object
, &overlay
);
4477 return HANDLED_NORMALLY
;
4478 /* Now OVERLAY is the overlay that gave us this property, or nil
4479 if it was a text property. */
4481 if (!STRINGP (it
->string
))
4482 object
= it
->w
->buffer
;
4484 display_replaced_p
= handle_display_spec (it
, propval
, object
, overlay
,
4486 FRAME_WINDOW_P (it
->f
));
4488 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
4491 /* Subroutine of handle_display_prop. Returns non-zero if the display
4492 specification in SPEC is a replacing specification, i.e. it would
4493 replace the text covered by `display' property with something else,
4494 such as an image or a display string. If SPEC includes any kind or
4495 `(space ...) specification, the value is 2; this is used by
4496 compute_display_string_pos, which see.
4498 See handle_single_display_spec for documentation of arguments.
4499 frame_window_p is non-zero if the window being redisplayed is on a
4500 GUI frame; this argument is used only if IT is NULL, see below.
4502 IT can be NULL, if this is called by the bidi reordering code
4503 through compute_display_string_pos, which see. In that case, this
4504 function only examines SPEC, but does not otherwise "handle" it, in
4505 the sense that it doesn't set up members of IT from the display
4508 handle_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4509 Lisp_Object overlay
, struct text_pos
*position
,
4510 ptrdiff_t bufpos
, int frame_window_p
)
4512 int replacing_p
= 0;
4516 /* Simple specifications. */
4517 && !EQ (XCAR (spec
), Qimage
)
4518 && !EQ (XCAR (spec
), Qspace
)
4519 && !EQ (XCAR (spec
), Qwhen
)
4520 && !EQ (XCAR (spec
), Qslice
)
4521 && !EQ (XCAR (spec
), Qspace_width
)
4522 && !EQ (XCAR (spec
), Qheight
)
4523 && !EQ (XCAR (spec
), Qraise
)
4524 /* Marginal area specifications. */
4525 && !(CONSP (XCAR (spec
)) && EQ (XCAR (XCAR (spec
)), Qmargin
))
4526 && !EQ (XCAR (spec
), Qleft_fringe
)
4527 && !EQ (XCAR (spec
), Qright_fringe
)
4528 && !NILP (XCAR (spec
)))
4530 for (; CONSP (spec
); spec
= XCDR (spec
))
4532 if ((rv
= handle_single_display_spec (it
, XCAR (spec
), object
,
4533 overlay
, position
, bufpos
,
4534 replacing_p
, frame_window_p
)))
4537 /* If some text in a string is replaced, `position' no
4538 longer points to the position of `object'. */
4539 if (!it
|| STRINGP (object
))
4544 else if (VECTORP (spec
))
4547 for (i
= 0; i
< ASIZE (spec
); ++i
)
4548 if ((rv
= handle_single_display_spec (it
, AREF (spec
, i
), object
,
4549 overlay
, position
, bufpos
,
4550 replacing_p
, frame_window_p
)))
4553 /* If some text in a string is replaced, `position' no
4554 longer points to the position of `object'. */
4555 if (!it
|| STRINGP (object
))
4561 if ((rv
= handle_single_display_spec (it
, spec
, object
, overlay
,
4562 position
, bufpos
, 0,
4570 /* Value is the position of the end of the `display' property starting
4571 at START_POS in OBJECT. */
4573 static struct text_pos
4574 display_prop_end (struct it
*it
, Lisp_Object object
, struct text_pos start_pos
)
4577 struct text_pos end_pos
;
4579 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
4580 Qdisplay
, object
, Qnil
);
4581 CHARPOS (end_pos
) = XFASTINT (end
);
4582 if (STRINGP (object
))
4583 compute_string_pos (&end_pos
, start_pos
, it
->string
);
4585 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
4591 /* Set up IT from a single `display' property specification SPEC. OBJECT
4592 is the object in which the `display' property was found. *POSITION
4593 is the position in OBJECT at which the `display' property was found.
4594 BUFPOS is the buffer position of OBJECT (different from POSITION if
4595 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
4596 previously saw a display specification which already replaced text
4597 display with something else, for example an image; we ignore such
4598 properties after the first one has been processed.
4600 OVERLAY is the overlay this `display' property came from,
4601 or nil if it was a text property.
4603 If SPEC is a `space' or `image' specification, and in some other
4604 cases too, set *POSITION to the position where the `display'
4607 If IT is NULL, only examine the property specification in SPEC, but
4608 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
4609 is intended to be displayed in a window on a GUI frame.
4611 Value is non-zero if something was found which replaces the display
4612 of buffer or string text. */
4615 handle_single_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4616 Lisp_Object overlay
, struct text_pos
*position
,
4617 ptrdiff_t bufpos
, int display_replaced_p
,
4621 Lisp_Object location
, value
;
4622 struct text_pos start_pos
= *position
;
4625 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4626 If the result is non-nil, use VALUE instead of SPEC. */
4628 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
4637 if (!NILP (form
) && !EQ (form
, Qt
))
4639 ptrdiff_t count
= SPECPDL_INDEX ();
4640 struct gcpro gcpro1
;
4642 /* Bind `object' to the object having the `display' property, a
4643 buffer or string. Bind `position' to the position in the
4644 object where the property was found, and `buffer-position'
4645 to the current position in the buffer. */
4648 XSETBUFFER (object
, current_buffer
);
4649 specbind (Qobject
, object
);
4650 specbind (Qposition
, make_number (CHARPOS (*position
)));
4651 specbind (Qbuffer_position
, make_number (bufpos
));
4653 form
= safe_eval (form
);
4655 unbind_to (count
, Qnil
);
4661 /* Handle `(height HEIGHT)' specifications. */
4663 && EQ (XCAR (spec
), Qheight
)
4664 && CONSP (XCDR (spec
)))
4668 if (!FRAME_WINDOW_P (it
->f
))
4671 it
->font_height
= XCAR (XCDR (spec
));
4672 if (!NILP (it
->font_height
))
4674 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4675 int new_height
= -1;
4677 if (CONSP (it
->font_height
)
4678 && (EQ (XCAR (it
->font_height
), Qplus
)
4679 || EQ (XCAR (it
->font_height
), Qminus
))
4680 && CONSP (XCDR (it
->font_height
))
4681 && RANGED_INTEGERP (0, XCAR (XCDR (it
->font_height
)), INT_MAX
))
4683 /* `(+ N)' or `(- N)' where N is an integer. */
4684 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4685 if (EQ (XCAR (it
->font_height
), Qplus
))
4687 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4689 else if (FUNCTIONP (it
->font_height
))
4691 /* Call function with current height as argument.
4692 Value is the new height. */
4694 height
= safe_call1 (it
->font_height
,
4695 face
->lface
[LFACE_HEIGHT_INDEX
]);
4696 if (NUMBERP (height
))
4697 new_height
= XFLOATINT (height
);
4699 else if (NUMBERP (it
->font_height
))
4701 /* Value is a multiple of the canonical char height. */
4704 f
= FACE_FROM_ID (it
->f
,
4705 lookup_basic_face (it
->f
, DEFAULT_FACE_ID
));
4706 new_height
= (XFLOATINT (it
->font_height
)
4707 * XINT (f
->lface
[LFACE_HEIGHT_INDEX
]));
4711 /* Evaluate IT->font_height with `height' bound to the
4712 current specified height to get the new height. */
4713 ptrdiff_t count
= SPECPDL_INDEX ();
4715 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4716 value
= safe_eval (it
->font_height
);
4717 unbind_to (count
, Qnil
);
4719 if (NUMBERP (value
))
4720 new_height
= XFLOATINT (value
);
4724 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4731 /* Handle `(space-width WIDTH)'. */
4733 && EQ (XCAR (spec
), Qspace_width
)
4734 && CONSP (XCDR (spec
)))
4738 if (!FRAME_WINDOW_P (it
->f
))
4741 value
= XCAR (XCDR (spec
));
4742 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4743 it
->space_width
= value
;
4749 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4751 && EQ (XCAR (spec
), Qslice
))
4757 if (!FRAME_WINDOW_P (it
->f
))
4760 if (tem
= XCDR (spec
), CONSP (tem
))
4762 it
->slice
.x
= XCAR (tem
);
4763 if (tem
= XCDR (tem
), CONSP (tem
))
4765 it
->slice
.y
= XCAR (tem
);
4766 if (tem
= XCDR (tem
), CONSP (tem
))
4768 it
->slice
.width
= XCAR (tem
);
4769 if (tem
= XCDR (tem
), CONSP (tem
))
4770 it
->slice
.height
= XCAR (tem
);
4779 /* Handle `(raise FACTOR)'. */
4781 && EQ (XCAR (spec
), Qraise
)
4782 && CONSP (XCDR (spec
)))
4786 if (!FRAME_WINDOW_P (it
->f
))
4789 #ifdef HAVE_WINDOW_SYSTEM
4790 value
= XCAR (XCDR (spec
));
4791 if (NUMBERP (value
))
4793 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4794 it
->voffset
= - (XFLOATINT (value
)
4795 * (FONT_HEIGHT (face
->font
)));
4797 #endif /* HAVE_WINDOW_SYSTEM */
4803 /* Don't handle the other kinds of display specifications
4804 inside a string that we got from a `display' property. */
4805 if (it
&& it
->string_from_display_prop_p
)
4808 /* Characters having this form of property are not displayed, so
4809 we have to find the end of the property. */
4812 start_pos
= *position
;
4813 *position
= display_prop_end (it
, object
, start_pos
);
4817 /* Stop the scan at that end position--we assume that all
4818 text properties change there. */
4820 it
->stop_charpos
= position
->charpos
;
4822 /* Handle `(left-fringe BITMAP [FACE])'
4823 and `(right-fringe BITMAP [FACE])'. */
4825 && (EQ (XCAR (spec
), Qleft_fringe
)
4826 || EQ (XCAR (spec
), Qright_fringe
))
4827 && CONSP (XCDR (spec
)))
4833 if (!FRAME_WINDOW_P (it
->f
))
4834 /* If we return here, POSITION has been advanced
4835 across the text with this property. */
4837 /* Synchronize the bidi iterator with POSITION. This is
4838 needed because we are not going to push the iterator
4839 on behalf of this display property, so there will be
4840 no pop_it call to do this synchronization for us. */
4843 it
->position
= *position
;
4844 iterate_out_of_display_property (it
);
4845 *position
= it
->position
;
4850 else if (!frame_window_p
)
4853 #ifdef HAVE_WINDOW_SYSTEM
4854 value
= XCAR (XCDR (spec
));
4855 if (!SYMBOLP (value
)
4856 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
4857 /* If we return here, POSITION has been advanced
4858 across the text with this property. */
4860 if (it
&& it
->bidi_p
)
4862 it
->position
= *position
;
4863 iterate_out_of_display_property (it
);
4864 *position
= it
->position
;
4871 int face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);;
4873 if (CONSP (XCDR (XCDR (spec
))))
4875 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
4876 int face_id2
= lookup_derived_face (it
->f
, face_name
,
4882 /* Save current settings of IT so that we can restore them
4883 when we are finished with the glyph property value. */
4884 push_it (it
, position
);
4886 it
->area
= TEXT_AREA
;
4887 it
->what
= IT_IMAGE
;
4888 it
->image_id
= -1; /* no image */
4889 it
->position
= start_pos
;
4890 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4891 it
->method
= GET_FROM_IMAGE
;
4892 it
->from_overlay
= Qnil
;
4893 it
->face_id
= face_id
;
4894 it
->from_disp_prop_p
= 1;
4896 /* Say that we haven't consumed the characters with
4897 `display' property yet. The call to pop_it in
4898 set_iterator_to_next will clean this up. */
4899 *position
= start_pos
;
4901 if (EQ (XCAR (spec
), Qleft_fringe
))
4903 it
->left_user_fringe_bitmap
= fringe_bitmap
;
4904 it
->left_user_fringe_face_id
= face_id
;
4908 it
->right_user_fringe_bitmap
= fringe_bitmap
;
4909 it
->right_user_fringe_face_id
= face_id
;
4912 #endif /* HAVE_WINDOW_SYSTEM */
4916 /* Prepare to handle `((margin left-margin) ...)',
4917 `((margin right-margin) ...)' and `((margin nil) ...)'
4918 prefixes for display specifications. */
4919 location
= Qunbound
;
4920 if (CONSP (spec
) && CONSP (XCAR (spec
)))
4924 value
= XCDR (spec
);
4926 value
= XCAR (value
);
4929 if (EQ (XCAR (tem
), Qmargin
)
4930 && (tem
= XCDR (tem
),
4931 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
4933 || EQ (tem
, Qleft_margin
)
4934 || EQ (tem
, Qright_margin
))))
4938 if (EQ (location
, Qunbound
))
4944 /* After this point, VALUE is the property after any
4945 margin prefix has been stripped. It must be a string,
4946 an image specification, or `(space ...)'.
4948 LOCATION specifies where to display: `left-margin',
4949 `right-margin' or nil. */
4951 valid_p
= (STRINGP (value
)
4952 #ifdef HAVE_WINDOW_SYSTEM
4953 || ((it
? FRAME_WINDOW_P (it
->f
) : frame_window_p
)
4954 && valid_image_p (value
))
4955 #endif /* not HAVE_WINDOW_SYSTEM */
4956 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
4958 if (valid_p
&& !display_replaced_p
)
4964 /* Callers need to know whether the display spec is any kind
4965 of `(space ...)' spec that is about to affect text-area
4967 if (CONSP (value
) && EQ (XCAR (value
), Qspace
) && NILP (location
))
4972 /* Save current settings of IT so that we can restore them
4973 when we are finished with the glyph property value. */
4974 push_it (it
, position
);
4975 it
->from_overlay
= overlay
;
4976 it
->from_disp_prop_p
= 1;
4978 if (NILP (location
))
4979 it
->area
= TEXT_AREA
;
4980 else if (EQ (location
, Qleft_margin
))
4981 it
->area
= LEFT_MARGIN_AREA
;
4983 it
->area
= RIGHT_MARGIN_AREA
;
4985 if (STRINGP (value
))
4988 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4989 it
->current
.overlay_string_index
= -1;
4990 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4991 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
4992 it
->method
= GET_FROM_STRING
;
4993 it
->stop_charpos
= 0;
4995 it
->base_level_stop
= 0;
4996 it
->string_from_display_prop_p
= 1;
4997 /* Say that we haven't consumed the characters with
4998 `display' property yet. The call to pop_it in
4999 set_iterator_to_next will clean this up. */
5000 if (BUFFERP (object
))
5001 *position
= start_pos
;
5003 /* Force paragraph direction to be that of the parent
5004 object. If the parent object's paragraph direction is
5005 not yet determined, default to L2R. */
5006 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5007 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5009 it
->paragraph_embedding
= L2R
;
5011 /* Set up the bidi iterator for this display string. */
5014 it
->bidi_it
.string
.lstring
= it
->string
;
5015 it
->bidi_it
.string
.s
= NULL
;
5016 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5017 it
->bidi_it
.string
.bufpos
= bufpos
;
5018 it
->bidi_it
.string
.from_disp_str
= 1;
5019 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5020 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5023 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
5025 it
->method
= GET_FROM_STRETCH
;
5027 *position
= it
->position
= start_pos
;
5028 retval
= 1 + (it
->area
== TEXT_AREA
);
5030 #ifdef HAVE_WINDOW_SYSTEM
5033 it
->what
= IT_IMAGE
;
5034 it
->image_id
= lookup_image (it
->f
, value
);
5035 it
->position
= start_pos
;
5036 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
5037 it
->method
= GET_FROM_IMAGE
;
5039 /* Say that we haven't consumed the characters with
5040 `display' property yet. The call to pop_it in
5041 set_iterator_to_next will clean this up. */
5042 *position
= start_pos
;
5044 #endif /* HAVE_WINDOW_SYSTEM */
5049 /* Invalid property or property not supported. Restore
5050 POSITION to what it was before. */
5051 *position
= start_pos
;
5055 /* Check if PROP is a display property value whose text should be
5056 treated as intangible. OVERLAY is the overlay from which PROP
5057 came, or nil if it came from a text property. CHARPOS and BYTEPOS
5058 specify the buffer position covered by PROP. */
5061 display_prop_intangible_p (Lisp_Object prop
, Lisp_Object overlay
,
5062 ptrdiff_t charpos
, ptrdiff_t bytepos
)
5064 int frame_window_p
= FRAME_WINDOW_P (XFRAME (selected_frame
));
5065 struct text_pos position
;
5067 SET_TEXT_POS (position
, charpos
, bytepos
);
5068 return handle_display_spec (NULL
, prop
, Qnil
, overlay
,
5069 &position
, charpos
, frame_window_p
);
5073 /* Return 1 if PROP is a display sub-property value containing STRING.
5075 Implementation note: this and the following function are really
5076 special cases of handle_display_spec and
5077 handle_single_display_spec, and should ideally use the same code.
5078 Until they do, these two pairs must be consistent and must be
5079 modified in sync. */
5082 single_display_spec_string_p (Lisp_Object prop
, Lisp_Object string
)
5084 if (EQ (string
, prop
))
5087 /* Skip over `when FORM'. */
5088 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
5093 /* Actually, the condition following `when' should be eval'ed,
5094 like handle_single_display_spec does, and we should return
5095 zero if it evaluates to nil. However, this function is
5096 called only when the buffer was already displayed and some
5097 glyph in the glyph matrix was found to come from a display
5098 string. Therefore, the condition was already evaluated, and
5099 the result was non-nil, otherwise the display string wouldn't
5100 have been displayed and we would have never been called for
5101 this property. Thus, we can skip the evaluation and assume
5102 its result is non-nil. */
5107 /* Skip over `margin LOCATION'. */
5108 if (EQ (XCAR (prop
), Qmargin
))
5119 return EQ (prop
, string
) || (CONSP (prop
) && EQ (XCAR (prop
), string
));
5123 /* Return 1 if STRING appears in the `display' property PROP. */
5126 display_prop_string_p (Lisp_Object prop
, Lisp_Object string
)
5129 && !EQ (XCAR (prop
), Qwhen
)
5130 && !(CONSP (XCAR (prop
)) && EQ (Qmargin
, XCAR (XCAR (prop
)))))
5132 /* A list of sub-properties. */
5133 while (CONSP (prop
))
5135 if (single_display_spec_string_p (XCAR (prop
), string
))
5140 else if (VECTORP (prop
))
5142 /* A vector of sub-properties. */
5144 for (i
= 0; i
< ASIZE (prop
); ++i
)
5145 if (single_display_spec_string_p (AREF (prop
, i
), string
))
5149 return single_display_spec_string_p (prop
, string
);
5154 /* Look for STRING in overlays and text properties in the current
5155 buffer, between character positions FROM and TO (excluding TO).
5156 BACK_P non-zero means look back (in this case, TO is supposed to be
5158 Value is the first character position where STRING was found, or
5159 zero if it wasn't found before hitting TO.
5161 This function may only use code that doesn't eval because it is
5162 called asynchronously from note_mouse_highlight. */
5165 string_buffer_position_lim (Lisp_Object string
,
5166 ptrdiff_t from
, ptrdiff_t to
, int back_p
)
5168 Lisp_Object limit
, prop
, pos
;
5171 pos
= make_number (max (from
, BEGV
));
5173 if (!back_p
) /* looking forward */
5175 limit
= make_number (min (to
, ZV
));
5176 while (!found
&& !EQ (pos
, limit
))
5178 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5179 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5182 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
,
5186 else /* looking back */
5188 limit
= make_number (max (to
, BEGV
));
5189 while (!found
&& !EQ (pos
, limit
))
5191 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
5192 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
5195 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
5200 return found
? XINT (pos
) : 0;
5203 /* Determine which buffer position in current buffer STRING comes from.
5204 AROUND_CHARPOS is an approximate position where it could come from.
5205 Value is the buffer position or 0 if it couldn't be determined.
5207 This function is necessary because we don't record buffer positions
5208 in glyphs generated from strings (to keep struct glyph small).
5209 This function may only use code that doesn't eval because it is
5210 called asynchronously from note_mouse_highlight. */
5213 string_buffer_position (Lisp_Object string
, ptrdiff_t around_charpos
)
5215 const int MAX_DISTANCE
= 1000;
5216 ptrdiff_t found
= string_buffer_position_lim (string
, around_charpos
,
5217 around_charpos
+ MAX_DISTANCE
,
5221 found
= string_buffer_position_lim (string
, around_charpos
,
5222 around_charpos
- MAX_DISTANCE
, 1);
5228 /***********************************************************************
5229 `composition' property
5230 ***********************************************************************/
5232 /* Set up iterator IT from `composition' property at its current
5233 position. Called from handle_stop. */
5235 static enum prop_handled
5236 handle_composition_prop (struct it
*it
)
5238 Lisp_Object prop
, string
;
5239 ptrdiff_t pos
, pos_byte
, start
, end
;
5241 if (STRINGP (it
->string
))
5245 pos
= IT_STRING_CHARPOS (*it
);
5246 pos_byte
= IT_STRING_BYTEPOS (*it
);
5247 string
= it
->string
;
5248 s
= SDATA (string
) + pos_byte
;
5249 it
->c
= STRING_CHAR (s
);
5253 pos
= IT_CHARPOS (*it
);
5254 pos_byte
= IT_BYTEPOS (*it
);
5256 it
->c
= FETCH_CHAR (pos_byte
);
5259 /* If there's a valid composition and point is not inside of the
5260 composition (in the case that the composition is from the current
5261 buffer), draw a glyph composed from the composition components. */
5262 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
5263 && COMPOSITION_VALID_P (start
, end
, prop
)
5264 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
5267 /* As we can't handle this situation (perhaps font-lock added
5268 a new composition), we just return here hoping that next
5269 redisplay will detect this composition much earlier. */
5270 return HANDLED_NORMALLY
;
5273 if (STRINGP (it
->string
))
5274 pos_byte
= string_char_to_byte (it
->string
, start
);
5276 pos_byte
= CHAR_TO_BYTE (start
);
5278 it
->cmp_it
.id
= get_composition_id (start
, pos_byte
, end
- start
,
5281 if (it
->cmp_it
.id
>= 0)
5284 it
->cmp_it
.nchars
= COMPOSITION_LENGTH (prop
);
5285 it
->cmp_it
.nglyphs
= -1;
5289 return HANDLED_NORMALLY
;
5294 /***********************************************************************
5296 ***********************************************************************/
5298 /* The following structure is used to record overlay strings for
5299 later sorting in load_overlay_strings. */
5301 struct overlay_entry
5303 Lisp_Object overlay
;
5310 /* Set up iterator IT from overlay strings at its current position.
5311 Called from handle_stop. */
5313 static enum prop_handled
5314 handle_overlay_change (struct it
*it
)
5316 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
5317 return HANDLED_RECOMPUTE_PROPS
;
5319 return HANDLED_NORMALLY
;
5323 /* Set up the next overlay string for delivery by IT, if there is an
5324 overlay string to deliver. Called by set_iterator_to_next when the
5325 end of the current overlay string is reached. If there are more
5326 overlay strings to display, IT->string and
5327 IT->current.overlay_string_index are set appropriately here.
5328 Otherwise IT->string is set to nil. */
5331 next_overlay_string (struct it
*it
)
5333 ++it
->current
.overlay_string_index
;
5334 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
5336 /* No more overlay strings. Restore IT's settings to what
5337 they were before overlay strings were processed, and
5338 continue to deliver from current_buffer. */
5340 it
->ellipsis_p
= (it
->stack
[it
->sp
- 1].display_ellipsis_p
!= 0);
5343 || (NILP (it
->string
)
5344 && it
->method
== GET_FROM_BUFFER
5345 && it
->stop_charpos
>= BEGV
5346 && it
->stop_charpos
<= it
->end_charpos
));
5347 it
->current
.overlay_string_index
= -1;
5348 it
->n_overlay_strings
= 0;
5349 it
->overlay_strings_charpos
= -1;
5350 /* If there's an empty display string on the stack, pop the
5351 stack, to resync the bidi iterator with IT's position. Such
5352 empty strings are pushed onto the stack in
5353 get_overlay_strings_1. */
5354 if (it
->sp
> 0 && STRINGP (it
->string
) && !SCHARS (it
->string
))
5357 /* If we're at the end of the buffer, record that we have
5358 processed the overlay strings there already, so that
5359 next_element_from_buffer doesn't try it again. */
5360 if (NILP (it
->string
) && IT_CHARPOS (*it
) >= it
->end_charpos
)
5361 it
->overlay_strings_at_end_processed_p
= 1;
5365 /* There are more overlay strings to process. If
5366 IT->current.overlay_string_index has advanced to a position
5367 where we must load IT->overlay_strings with more strings, do
5368 it. We must load at the IT->overlay_strings_charpos where
5369 IT->n_overlay_strings was originally computed; when invisible
5370 text is present, this might not be IT_CHARPOS (Bug#7016). */
5371 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
5373 if (it
->current
.overlay_string_index
&& i
== 0)
5374 load_overlay_strings (it
, it
->overlay_strings_charpos
);
5376 /* Initialize IT to deliver display elements from the overlay
5378 it
->string
= it
->overlay_strings
[i
];
5379 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5380 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
5381 it
->method
= GET_FROM_STRING
;
5382 it
->stop_charpos
= 0;
5383 it
->end_charpos
= SCHARS (it
->string
);
5384 if (it
->cmp_it
.stop_pos
>= 0)
5385 it
->cmp_it
.stop_pos
= 0;
5387 it
->base_level_stop
= 0;
5389 /* Set up the bidi iterator for this overlay string. */
5392 it
->bidi_it
.string
.lstring
= it
->string
;
5393 it
->bidi_it
.string
.s
= NULL
;
5394 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5395 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
5396 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5397 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5398 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5406 /* Compare two overlay_entry structures E1 and E2. Used as a
5407 comparison function for qsort in load_overlay_strings. Overlay
5408 strings for the same position are sorted so that
5410 1. All after-strings come in front of before-strings, except
5411 when they come from the same overlay.
5413 2. Within after-strings, strings are sorted so that overlay strings
5414 from overlays with higher priorities come first.
5416 2. Within before-strings, strings are sorted so that overlay
5417 strings from overlays with higher priorities come last.
5419 Value is analogous to strcmp. */
5423 compare_overlay_entries (const void *e1
, const void *e2
)
5425 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
5426 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
5429 if (entry1
->after_string_p
!= entry2
->after_string_p
)
5431 /* Let after-strings appear in front of before-strings if
5432 they come from different overlays. */
5433 if (EQ (entry1
->overlay
, entry2
->overlay
))
5434 result
= entry1
->after_string_p
? 1 : -1;
5436 result
= entry1
->after_string_p
? -1 : 1;
5438 else if (entry1
->priority
!= entry2
->priority
)
5440 if (entry1
->after_string_p
)
5441 /* After-strings sorted in order of decreasing priority. */
5442 result
= entry2
->priority
< entry1
->priority
? -1 : 1;
5444 /* Before-strings sorted in order of increasing priority. */
5445 result
= entry1
->priority
< entry2
->priority
? -1 : 1;
5454 /* Load the vector IT->overlay_strings with overlay strings from IT's
5455 current buffer position, or from CHARPOS if that is > 0. Set
5456 IT->n_overlays to the total number of overlay strings found.
5458 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
5459 a time. On entry into load_overlay_strings,
5460 IT->current.overlay_string_index gives the number of overlay
5461 strings that have already been loaded by previous calls to this
5464 IT->add_overlay_start contains an additional overlay start
5465 position to consider for taking overlay strings from, if non-zero.
5466 This position comes into play when the overlay has an `invisible'
5467 property, and both before and after-strings. When we've skipped to
5468 the end of the overlay, because of its `invisible' property, we
5469 nevertheless want its before-string to appear.
5470 IT->add_overlay_start will contain the overlay start position
5473 Overlay strings are sorted so that after-string strings come in
5474 front of before-string strings. Within before and after-strings,
5475 strings are sorted by overlay priority. See also function
5476 compare_overlay_entries. */
5479 load_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5481 Lisp_Object overlay
, window
, str
, invisible
;
5482 struct Lisp_Overlay
*ov
;
5483 ptrdiff_t start
, end
;
5484 ptrdiff_t size
= 20;
5485 ptrdiff_t n
= 0, i
, j
;
5487 struct overlay_entry
*entries
= alloca (size
* sizeof *entries
);
5491 charpos
= IT_CHARPOS (*it
);
5493 /* Append the overlay string STRING of overlay OVERLAY to vector
5494 `entries' which has size `size' and currently contains `n'
5495 elements. AFTER_P non-zero means STRING is an after-string of
5497 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5500 Lisp_Object priority; \
5504 struct overlay_entry *old = entries; \
5505 SAFE_NALLOCA (entries, 2, size); \
5506 memcpy (entries, old, size * sizeof *entries); \
5510 entries[n].string = (STRING); \
5511 entries[n].overlay = (OVERLAY); \
5512 priority = Foverlay_get ((OVERLAY), Qpriority); \
5513 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5514 entries[n].after_string_p = (AFTER_P); \
5519 /* Process overlay before the overlay center. */
5520 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
5522 XSETMISC (overlay
, ov
);
5523 eassert (OVERLAYP (overlay
));
5524 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5525 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5530 /* Skip this overlay if it doesn't start or end at IT's current
5532 if (end
!= charpos
&& start
!= charpos
)
5535 /* Skip this overlay if it doesn't apply to IT->w. */
5536 window
= Foverlay_get (overlay
, Qwindow
);
5537 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5540 /* If the text ``under'' the overlay is invisible, both before-
5541 and after-strings from this overlay are visible; start and
5542 end position are indistinguishable. */
5543 invisible
= Foverlay_get (overlay
, Qinvisible
);
5544 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5546 /* If overlay has a non-empty before-string, record it. */
5547 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5548 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5550 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5552 /* If overlay has a non-empty after-string, record it. */
5553 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5554 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5556 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5559 /* Process overlays after the overlay center. */
5560 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
5562 XSETMISC (overlay
, ov
);
5563 eassert (OVERLAYP (overlay
));
5564 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5565 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5567 if (start
> charpos
)
5570 /* Skip this overlay if it doesn't start or end at IT's current
5572 if (end
!= charpos
&& start
!= charpos
)
5575 /* Skip this overlay if it doesn't apply to IT->w. */
5576 window
= Foverlay_get (overlay
, Qwindow
);
5577 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5580 /* If the text ``under'' the overlay is invisible, it has a zero
5581 dimension, and both before- and after-strings apply. */
5582 invisible
= Foverlay_get (overlay
, Qinvisible
);
5583 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5585 /* If overlay has a non-empty before-string, record it. */
5586 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5587 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5589 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5591 /* If overlay has a non-empty after-string, record it. */
5592 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5593 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5595 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5598 #undef RECORD_OVERLAY_STRING
5602 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
5604 /* Record number of overlay strings, and where we computed it. */
5605 it
->n_overlay_strings
= n
;
5606 it
->overlay_strings_charpos
= charpos
;
5608 /* IT->current.overlay_string_index is the number of overlay strings
5609 that have already been consumed by IT. Copy some of the
5610 remaining overlay strings to IT->overlay_strings. */
5612 j
= it
->current
.overlay_string_index
;
5613 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
5615 it
->overlay_strings
[i
] = entries
[j
].string
;
5616 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
5624 /* Get the first chunk of overlay strings at IT's current buffer
5625 position, or at CHARPOS if that is > 0. Value is non-zero if at
5626 least one overlay string was found. */
5629 get_overlay_strings_1 (struct it
*it
, ptrdiff_t charpos
, int compute_stop_p
)
5631 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5632 process. This fills IT->overlay_strings with strings, and sets
5633 IT->n_overlay_strings to the total number of strings to process.
5634 IT->pos.overlay_string_index has to be set temporarily to zero
5635 because load_overlay_strings needs this; it must be set to -1
5636 when no overlay strings are found because a zero value would
5637 indicate a position in the first overlay string. */
5638 it
->current
.overlay_string_index
= 0;
5639 load_overlay_strings (it
, charpos
);
5641 /* If we found overlay strings, set up IT to deliver display
5642 elements from the first one. Otherwise set up IT to deliver
5643 from current_buffer. */
5644 if (it
->n_overlay_strings
)
5646 /* Make sure we know settings in current_buffer, so that we can
5647 restore meaningful values when we're done with the overlay
5650 compute_stop_pos (it
);
5651 eassert (it
->face_id
>= 0);
5653 /* Save IT's settings. They are restored after all overlay
5654 strings have been processed. */
5655 eassert (!compute_stop_p
|| it
->sp
== 0);
5657 /* When called from handle_stop, there might be an empty display
5658 string loaded. In that case, don't bother saving it. But
5659 don't use this optimization with the bidi iterator, since we
5660 need the corresponding pop_it call to resync the bidi
5661 iterator's position with IT's position, after we are done
5662 with the overlay strings. (The corresponding call to pop_it
5663 in case of an empty display string is in
5664 next_overlay_string.) */
5666 && STRINGP (it
->string
) && !SCHARS (it
->string
)))
5669 /* Set up IT to deliver display elements from the first overlay
5671 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5672 it
->string
= it
->overlay_strings
[0];
5673 it
->from_overlay
= Qnil
;
5674 it
->stop_charpos
= 0;
5675 eassert (STRINGP (it
->string
));
5676 it
->end_charpos
= SCHARS (it
->string
);
5678 it
->base_level_stop
= 0;
5679 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5680 it
->method
= GET_FROM_STRING
;
5681 it
->from_disp_prop_p
= 0;
5683 /* Force paragraph direction to be that of the parent
5685 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5686 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5688 it
->paragraph_embedding
= L2R
;
5690 /* Set up the bidi iterator for this overlay string. */
5693 ptrdiff_t pos
= (charpos
> 0 ? charpos
: IT_CHARPOS (*it
));
5695 it
->bidi_it
.string
.lstring
= it
->string
;
5696 it
->bidi_it
.string
.s
= NULL
;
5697 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5698 it
->bidi_it
.string
.bufpos
= pos
;
5699 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5700 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5701 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5706 it
->current
.overlay_string_index
= -1;
5711 get_overlay_strings (struct it
*it
, ptrdiff_t charpos
)
5714 it
->method
= GET_FROM_BUFFER
;
5716 (void) get_overlay_strings_1 (it
, charpos
, 1);
5720 /* Value is non-zero if we found at least one overlay string. */
5721 return STRINGP (it
->string
);
5726 /***********************************************************************
5727 Saving and restoring state
5728 ***********************************************************************/
5730 /* Save current settings of IT on IT->stack. Called, for example,
5731 before setting up IT for an overlay string, to be able to restore
5732 IT's settings to what they were after the overlay string has been
5733 processed. If POSITION is non-NULL, it is the position to save on
5734 the stack instead of IT->position. */
5737 push_it (struct it
*it
, struct text_pos
*position
)
5739 struct iterator_stack_entry
*p
;
5741 eassert (it
->sp
< IT_STACK_SIZE
);
5742 p
= it
->stack
+ it
->sp
;
5744 p
->stop_charpos
= it
->stop_charpos
;
5745 p
->prev_stop
= it
->prev_stop
;
5746 p
->base_level_stop
= it
->base_level_stop
;
5747 p
->cmp_it
= it
->cmp_it
;
5748 eassert (it
->face_id
>= 0);
5749 p
->face_id
= it
->face_id
;
5750 p
->string
= it
->string
;
5751 p
->method
= it
->method
;
5752 p
->from_overlay
= it
->from_overlay
;
5755 case GET_FROM_IMAGE
:
5756 p
->u
.image
.object
= it
->object
;
5757 p
->u
.image
.image_id
= it
->image_id
;
5758 p
->u
.image
.slice
= it
->slice
;
5760 case GET_FROM_STRETCH
:
5761 p
->u
.stretch
.object
= it
->object
;
5764 p
->position
= position
? *position
: it
->position
;
5765 p
->current
= it
->current
;
5766 p
->end_charpos
= it
->end_charpos
;
5767 p
->string_nchars
= it
->string_nchars
;
5769 p
->multibyte_p
= it
->multibyte_p
;
5770 p
->avoid_cursor_p
= it
->avoid_cursor_p
;
5771 p
->space_width
= it
->space_width
;
5772 p
->font_height
= it
->font_height
;
5773 p
->voffset
= it
->voffset
;
5774 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5775 p
->string_from_prefix_prop_p
= it
->string_from_prefix_prop_p
;
5776 p
->display_ellipsis_p
= 0;
5777 p
->line_wrap
= it
->line_wrap
;
5778 p
->bidi_p
= it
->bidi_p
;
5779 p
->paragraph_embedding
= it
->paragraph_embedding
;
5780 p
->from_disp_prop_p
= it
->from_disp_prop_p
;
5783 /* Save the state of the bidi iterator as well. */
5785 bidi_push_it (&it
->bidi_it
);
5789 iterate_out_of_display_property (struct it
*it
)
5791 int buffer_p
= !STRINGP (it
->string
);
5792 ptrdiff_t eob
= (buffer_p
? ZV
: it
->end_charpos
);
5793 ptrdiff_t bob
= (buffer_p
? BEGV
: 0);
5795 eassert (eob
>= CHARPOS (it
->position
) && CHARPOS (it
->position
) >= bob
);
5797 /* Maybe initialize paragraph direction. If we are at the beginning
5798 of a new paragraph, next_element_from_buffer may not have a
5799 chance to do that. */
5800 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< eob
)
5801 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
5802 /* prev_stop can be zero, so check against BEGV as well. */
5803 while (it
->bidi_it
.charpos
>= bob
5804 && it
->prev_stop
<= it
->bidi_it
.charpos
5805 && it
->bidi_it
.charpos
< CHARPOS (it
->position
)
5806 && it
->bidi_it
.charpos
< eob
)
5807 bidi_move_to_visually_next (&it
->bidi_it
);
5808 /* Record the stop_pos we just crossed, for when we cross it
5810 if (it
->bidi_it
.charpos
> CHARPOS (it
->position
))
5811 it
->prev_stop
= CHARPOS (it
->position
);
5812 /* If we ended up not where pop_it put us, resync IT's
5813 positional members with the bidi iterator. */
5814 if (it
->bidi_it
.charpos
!= CHARPOS (it
->position
))
5815 SET_TEXT_POS (it
->position
, it
->bidi_it
.charpos
, it
->bidi_it
.bytepos
);
5817 it
->current
.pos
= it
->position
;
5819 it
->current
.string_pos
= it
->position
;
5822 /* Restore IT's settings from IT->stack. Called, for example, when no
5823 more overlay strings must be processed, and we return to delivering
5824 display elements from a buffer, or when the end of a string from a
5825 `display' property is reached and we return to delivering display
5826 elements from an overlay string, or from a buffer. */
5829 pop_it (struct it
*it
)
5831 struct iterator_stack_entry
*p
;
5832 int from_display_prop
= it
->from_disp_prop_p
;
5834 eassert (it
->sp
> 0);
5836 p
= it
->stack
+ it
->sp
;
5837 it
->stop_charpos
= p
->stop_charpos
;
5838 it
->prev_stop
= p
->prev_stop
;
5839 it
->base_level_stop
= p
->base_level_stop
;
5840 it
->cmp_it
= p
->cmp_it
;
5841 it
->face_id
= p
->face_id
;
5842 it
->current
= p
->current
;
5843 it
->position
= p
->position
;
5844 it
->string
= p
->string
;
5845 it
->from_overlay
= p
->from_overlay
;
5846 if (NILP (it
->string
))
5847 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
5848 it
->method
= p
->method
;
5851 case GET_FROM_IMAGE
:
5852 it
->image_id
= p
->u
.image
.image_id
;
5853 it
->object
= p
->u
.image
.object
;
5854 it
->slice
= p
->u
.image
.slice
;
5856 case GET_FROM_STRETCH
:
5857 it
->object
= p
->u
.stretch
.object
;
5859 case GET_FROM_BUFFER
:
5860 it
->object
= it
->w
->buffer
;
5862 case GET_FROM_STRING
:
5863 it
->object
= it
->string
;
5865 case GET_FROM_DISPLAY_VECTOR
:
5867 it
->method
= GET_FROM_C_STRING
;
5868 else if (STRINGP (it
->string
))
5869 it
->method
= GET_FROM_STRING
;
5872 it
->method
= GET_FROM_BUFFER
;
5873 it
->object
= it
->w
->buffer
;
5876 it
->end_charpos
= p
->end_charpos
;
5877 it
->string_nchars
= p
->string_nchars
;
5879 it
->multibyte_p
= p
->multibyte_p
;
5880 it
->avoid_cursor_p
= p
->avoid_cursor_p
;
5881 it
->space_width
= p
->space_width
;
5882 it
->font_height
= p
->font_height
;
5883 it
->voffset
= p
->voffset
;
5884 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
5885 it
->string_from_prefix_prop_p
= p
->string_from_prefix_prop_p
;
5886 it
->line_wrap
= p
->line_wrap
;
5887 it
->bidi_p
= p
->bidi_p
;
5888 it
->paragraph_embedding
= p
->paragraph_embedding
;
5889 it
->from_disp_prop_p
= p
->from_disp_prop_p
;
5892 bidi_pop_it (&it
->bidi_it
);
5893 /* Bidi-iterate until we get out of the portion of text, if any,
5894 covered by a `display' text property or by an overlay with
5895 `display' property. (We cannot just jump there, because the
5896 internal coherency of the bidi iterator state can not be
5897 preserved across such jumps.) We also must determine the
5898 paragraph base direction if the overlay we just processed is
5899 at the beginning of a new paragraph. */
5900 if (from_display_prop
5901 && (it
->method
== GET_FROM_BUFFER
|| it
->method
== GET_FROM_STRING
))
5902 iterate_out_of_display_property (it
);
5904 eassert ((BUFFERP (it
->object
)
5905 && IT_CHARPOS (*it
) == it
->bidi_it
.charpos
5906 && IT_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
5907 || (STRINGP (it
->object
)
5908 && IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
5909 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
5910 || (CONSP (it
->object
) && it
->method
== GET_FROM_STRETCH
));
5916 /***********************************************************************
5918 ***********************************************************************/
5920 /* Set IT's current position to the previous line start. */
5923 back_to_previous_line_start (struct it
*it
)
5925 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
5926 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
5930 /* Move IT to the next line start.
5932 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5933 we skipped over part of the text (as opposed to moving the iterator
5934 continuously over the text). Otherwise, don't change the value
5937 If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
5938 iterator on the newline, if it was found.
5940 Newlines may come from buffer text, overlay strings, or strings
5941 displayed via the `display' property. That's the reason we can't
5942 simply use find_next_newline_no_quit.
5944 Note that this function may not skip over invisible text that is so
5945 because of text properties and immediately follows a newline. If
5946 it would, function reseat_at_next_visible_line_start, when called
5947 from set_iterator_to_next, would effectively make invisible
5948 characters following a newline part of the wrong glyph row, which
5949 leads to wrong cursor motion. */
5952 forward_to_next_line_start (struct it
*it
, int *skipped_p
,
5953 struct bidi_it
*bidi_it_prev
)
5955 ptrdiff_t old_selective
;
5956 int newline_found_p
, n
;
5957 const int MAX_NEWLINE_DISTANCE
= 500;
5959 /* If already on a newline, just consume it to avoid unintended
5960 skipping over invisible text below. */
5961 if (it
->what
== IT_CHARACTER
5963 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
5965 if (it
->bidi_p
&& bidi_it_prev
)
5966 *bidi_it_prev
= it
->bidi_it
;
5967 set_iterator_to_next (it
, 0);
5972 /* Don't handle selective display in the following. It's (a)
5973 unnecessary because it's done by the caller, and (b) leads to an
5974 infinite recursion because next_element_from_ellipsis indirectly
5975 calls this function. */
5976 old_selective
= it
->selective
;
5979 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5980 from buffer text. */
5981 for (n
= newline_found_p
= 0;
5982 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
5983 n
+= STRINGP (it
->string
) ? 0 : 1)
5985 if (!get_next_display_element (it
))
5987 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
5988 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
5989 *bidi_it_prev
= it
->bidi_it
;
5990 set_iterator_to_next (it
, 0);
5993 /* If we didn't find a newline near enough, see if we can use a
5995 if (!newline_found_p
)
5997 ptrdiff_t start
= IT_CHARPOS (*it
);
5998 ptrdiff_t limit
= find_next_newline_no_quit (start
, 1);
6001 eassert (!STRINGP (it
->string
));
6003 /* If there isn't any `display' property in sight, and no
6004 overlays, we can just use the position of the newline in
6006 if (it
->stop_charpos
>= limit
6007 || ((pos
= Fnext_single_property_change (make_number (start
),
6009 make_number (limit
)),
6011 && next_overlay_change (start
) == ZV
))
6015 IT_CHARPOS (*it
) = limit
;
6016 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
6020 struct bidi_it bprev
;
6022 /* Help bidi.c avoid expensive searches for display
6023 properties and overlays, by telling it that there are
6024 none up to `limit'. */
6025 if (it
->bidi_it
.disp_pos
< limit
)
6027 it
->bidi_it
.disp_pos
= limit
;
6028 it
->bidi_it
.disp_prop
= 0;
6031 bprev
= it
->bidi_it
;
6032 bidi_move_to_visually_next (&it
->bidi_it
);
6033 } while (it
->bidi_it
.charpos
!= limit
);
6034 IT_CHARPOS (*it
) = limit
;
6035 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6037 *bidi_it_prev
= bprev
;
6039 *skipped_p
= newline_found_p
= 1;
6043 while (get_next_display_element (it
)
6044 && !newline_found_p
)
6046 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
6047 if (newline_found_p
&& it
->bidi_p
&& bidi_it_prev
)
6048 *bidi_it_prev
= it
->bidi_it
;
6049 set_iterator_to_next (it
, 0);
6054 it
->selective
= old_selective
;
6055 return newline_found_p
;
6059 /* Set IT's current position to the previous visible line start. Skip
6060 invisible text that is so either due to text properties or due to
6061 selective display. Caution: this does not change IT->current_x and
6065 back_to_previous_visible_line_start (struct it
*it
)
6067 while (IT_CHARPOS (*it
) > BEGV
)
6069 back_to_previous_line_start (it
);
6071 if (IT_CHARPOS (*it
) <= BEGV
)
6074 /* If selective > 0, then lines indented more than its value are
6076 if (it
->selective
> 0
6077 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6081 /* Check the newline before point for invisibility. */
6084 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
6085 Qinvisible
, it
->window
);
6086 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
6090 if (IT_CHARPOS (*it
) <= BEGV
)
6095 void *it2data
= NULL
;
6098 Lisp_Object val
, overlay
;
6100 SAVE_IT (it2
, *it
, it2data
);
6102 /* If newline is part of a composition, continue from start of composition */
6103 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
6104 && beg
< IT_CHARPOS (*it
))
6107 /* If newline is replaced by a display property, find start of overlay
6108 or interval and continue search from that point. */
6109 pos
= --IT_CHARPOS (it2
);
6112 bidi_unshelve_cache (NULL
, 0);
6113 it2
.string_from_display_prop_p
= 0;
6114 it2
.from_disp_prop_p
= 0;
6115 if (handle_display_prop (&it2
) == HANDLED_RETURN
6116 && !NILP (val
= get_char_property_and_overlay
6117 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
6118 && (OVERLAYP (overlay
)
6119 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
6120 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
6122 RESTORE_IT (it
, it
, it2data
);
6126 /* Newline is not replaced by anything -- so we are done. */
6127 RESTORE_IT (it
, it
, it2data
);
6133 IT_CHARPOS (*it
) = beg
;
6134 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
6138 it
->continuation_lines_width
= 0;
6140 eassert (IT_CHARPOS (*it
) >= BEGV
);
6141 eassert (IT_CHARPOS (*it
) == BEGV
6142 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6147 /* Reseat iterator IT at the previous visible line start. Skip
6148 invisible text that is so either due to text properties or due to
6149 selective display. At the end, update IT's overlay information,
6150 face information etc. */
6153 reseat_at_previous_visible_line_start (struct it
*it
)
6155 back_to_previous_visible_line_start (it
);
6156 reseat (it
, it
->current
.pos
, 1);
6161 /* Reseat iterator IT on the next visible line start in the current
6162 buffer. ON_NEWLINE_P non-zero means position IT on the newline
6163 preceding the line start. Skip over invisible text that is so
6164 because of selective display. Compute faces, overlays etc at the
6165 new position. Note that this function does not skip over text that
6166 is invisible because of text properties. */
6169 reseat_at_next_visible_line_start (struct it
*it
, int on_newline_p
)
6171 int newline_found_p
, skipped_p
= 0;
6172 struct bidi_it bidi_it_prev
;
6174 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6176 /* Skip over lines that are invisible because they are indented
6177 more than the value of IT->selective. */
6178 if (it
->selective
> 0)
6179 while (IT_CHARPOS (*it
) < ZV
6180 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6183 eassert (IT_BYTEPOS (*it
) == BEGV
6184 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
6186 forward_to_next_line_start (it
, &skipped_p
, &bidi_it_prev
);
6189 /* Position on the newline if that's what's requested. */
6190 if (on_newline_p
&& newline_found_p
)
6192 if (STRINGP (it
->string
))
6194 if (IT_STRING_CHARPOS (*it
) > 0)
6198 --IT_STRING_CHARPOS (*it
);
6199 --IT_STRING_BYTEPOS (*it
);
6203 /* We need to restore the bidi iterator to the state
6204 it had on the newline, and resync the IT's
6205 position with that. */
6206 it
->bidi_it
= bidi_it_prev
;
6207 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6208 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6212 else if (IT_CHARPOS (*it
) > BEGV
)
6221 /* We need to restore the bidi iterator to the state it
6222 had on the newline and resync IT with that. */
6223 it
->bidi_it
= bidi_it_prev
;
6224 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6225 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6227 reseat (it
, it
->current
.pos
, 0);
6231 reseat (it
, it
->current
.pos
, 0);
6238 /***********************************************************************
6239 Changing an iterator's position
6240 ***********************************************************************/
6242 /* Change IT's current position to POS in current_buffer. If FORCE_P
6243 is non-zero, always check for text properties at the new position.
6244 Otherwise, text properties are only looked up if POS >=
6245 IT->check_charpos of a property. */
6248 reseat (struct it
*it
, struct text_pos pos
, int force_p
)
6250 ptrdiff_t original_pos
= IT_CHARPOS (*it
);
6252 reseat_1 (it
, pos
, 0);
6254 /* Determine where to check text properties. Avoid doing it
6255 where possible because text property lookup is very expensive. */
6257 || CHARPOS (pos
) > it
->stop_charpos
6258 || CHARPOS (pos
) < original_pos
)
6262 /* For bidi iteration, we need to prime prev_stop and
6263 base_level_stop with our best estimations. */
6264 /* Implementation note: Of course, POS is not necessarily a
6265 stop position, so assigning prev_pos to it is a lie; we
6266 should have called compute_stop_backwards. However, if
6267 the current buffer does not include any R2L characters,
6268 that call would be a waste of cycles, because the
6269 iterator will never move back, and thus never cross this
6270 "fake" stop position. So we delay that backward search
6271 until the time we really need it, in next_element_from_buffer. */
6272 if (CHARPOS (pos
) != it
->prev_stop
)
6273 it
->prev_stop
= CHARPOS (pos
);
6274 if (CHARPOS (pos
) < it
->base_level_stop
)
6275 it
->base_level_stop
= 0; /* meaning it's unknown */
6281 it
->prev_stop
= it
->base_level_stop
= 0;
6290 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
6291 IT->stop_pos to POS, also. */
6294 reseat_1 (struct it
*it
, struct text_pos pos
, int set_stop_p
)
6296 /* Don't call this function when scanning a C string. */
6297 eassert (it
->s
== NULL
);
6299 /* POS must be a reasonable value. */
6300 eassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
6302 it
->current
.pos
= it
->position
= pos
;
6303 it
->end_charpos
= ZV
;
6305 it
->current
.dpvec_index
= -1;
6306 it
->current
.overlay_string_index
= -1;
6307 IT_STRING_CHARPOS (*it
) = -1;
6308 IT_STRING_BYTEPOS (*it
) = -1;
6310 it
->method
= GET_FROM_BUFFER
;
6311 it
->object
= it
->w
->buffer
;
6312 it
->area
= TEXT_AREA
;
6313 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
6315 it
->string_from_display_prop_p
= 0;
6316 it
->string_from_prefix_prop_p
= 0;
6318 it
->from_disp_prop_p
= 0;
6319 it
->face_before_selective_p
= 0;
6322 bidi_init_it (IT_CHARPOS (*it
), IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6324 bidi_unshelve_cache (NULL
, 0);
6325 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6326 it
->bidi_it
.string
.s
= NULL
;
6327 it
->bidi_it
.string
.lstring
= Qnil
;
6328 it
->bidi_it
.string
.bufpos
= 0;
6329 it
->bidi_it
.string
.unibyte
= 0;
6334 it
->stop_charpos
= CHARPOS (pos
);
6335 it
->base_level_stop
= CHARPOS (pos
);
6337 /* This make the information stored in it->cmp_it invalidate. */
6342 /* Set up IT for displaying a string, starting at CHARPOS in window W.
6343 If S is non-null, it is a C string to iterate over. Otherwise,
6344 STRING gives a Lisp string to iterate over.
6346 If PRECISION > 0, don't return more then PRECISION number of
6347 characters from the string.
6349 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
6350 characters have been returned. FIELD_WIDTH < 0 means an infinite
6353 MULTIBYTE = 0 means disable processing of multibyte characters,
6354 MULTIBYTE > 0 means enable it,
6355 MULTIBYTE < 0 means use IT->multibyte_p.
6357 IT must be initialized via a prior call to init_iterator before
6358 calling this function. */
6361 reseat_to_string (struct it
*it
, const char *s
, Lisp_Object string
,
6362 ptrdiff_t charpos
, ptrdiff_t precision
, int field_width
,
6365 /* No region in strings. */
6366 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
6368 /* No text property checks performed by default, but see below. */
6369 it
->stop_charpos
= -1;
6371 /* Set iterator position and end position. */
6372 memset (&it
->current
, 0, sizeof it
->current
);
6373 it
->current
.overlay_string_index
= -1;
6374 it
->current
.dpvec_index
= -1;
6375 eassert (charpos
>= 0);
6377 /* If STRING is specified, use its multibyteness, otherwise use the
6378 setting of MULTIBYTE, if specified. */
6380 it
->multibyte_p
= multibyte
> 0;
6382 /* Bidirectional reordering of strings is controlled by the default
6383 value of bidi-display-reordering. Don't try to reorder while
6384 loading loadup.el, as the necessary character property tables are
6385 not yet available. */
6388 && !NILP (BVAR (&buffer_defaults
, bidi_display_reordering
));
6392 eassert (STRINGP (string
));
6393 it
->string
= string
;
6395 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
6396 it
->method
= GET_FROM_STRING
;
6397 it
->current
.string_pos
= string_pos (charpos
, string
);
6401 it
->bidi_it
.string
.lstring
= string
;
6402 it
->bidi_it
.string
.s
= NULL
;
6403 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6404 it
->bidi_it
.string
.bufpos
= 0;
6405 it
->bidi_it
.string
.from_disp_str
= 0;
6406 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6407 bidi_init_it (charpos
, IT_STRING_BYTEPOS (*it
),
6408 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
6413 it
->s
= (const unsigned char *) s
;
6416 /* Note that we use IT->current.pos, not it->current.string_pos,
6417 for displaying C strings. */
6418 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
6419 if (it
->multibyte_p
)
6421 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
6422 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
6426 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
6427 it
->end_charpos
= it
->string_nchars
= strlen (s
);
6432 it
->bidi_it
.string
.lstring
= Qnil
;
6433 it
->bidi_it
.string
.s
= (const unsigned char *) s
;
6434 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6435 it
->bidi_it
.string
.bufpos
= 0;
6436 it
->bidi_it
.string
.from_disp_str
= 0;
6437 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
6438 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
6441 it
->method
= GET_FROM_C_STRING
;
6444 /* PRECISION > 0 means don't return more than PRECISION characters
6446 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
6448 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
6450 it
->bidi_it
.string
.schars
= it
->end_charpos
;
6453 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
6454 characters have been returned. FIELD_WIDTH == 0 means don't pad,
6455 FIELD_WIDTH < 0 means infinite field width. This is useful for
6456 padding with `-' at the end of a mode line. */
6457 if (field_width
< 0)
6458 field_width
= INFINITY
;
6459 /* Implementation note: We deliberately don't enlarge
6460 it->bidi_it.string.schars here to fit it->end_charpos, because
6461 the bidi iterator cannot produce characters out of thin air. */
6462 if (field_width
> it
->end_charpos
- charpos
)
6463 it
->end_charpos
= charpos
+ field_width
;
6465 /* Use the standard display table for displaying strings. */
6466 if (DISP_TABLE_P (Vstandard_display_table
))
6467 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
6469 it
->stop_charpos
= charpos
;
6470 it
->prev_stop
= charpos
;
6471 it
->base_level_stop
= 0;
6474 it
->bidi_it
.first_elt
= 1;
6475 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
6476 it
->bidi_it
.disp_pos
= -1;
6478 if (s
== NULL
&& it
->multibyte_p
)
6480 ptrdiff_t endpos
= SCHARS (it
->string
);
6481 if (endpos
> it
->end_charpos
)
6482 endpos
= it
->end_charpos
;
6483 composition_compute_stop_pos (&it
->cmp_it
, charpos
, -1, endpos
,
6491 /***********************************************************************
6493 ***********************************************************************/
6495 /* Map enum it_method value to corresponding next_element_from_* function. */
6497 static int (* get_next_element
[NUM_IT_METHODS
]) (struct it
*it
) =
6499 next_element_from_buffer
,
6500 next_element_from_display_vector
,
6501 next_element_from_string
,
6502 next_element_from_c_string
,
6503 next_element_from_image
,
6504 next_element_from_stretch
6507 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
6510 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
6511 (possibly with the following characters). */
6513 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
6514 ((IT)->cmp_it.id >= 0 \
6515 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
6516 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
6517 END_CHARPOS, (IT)->w, \
6518 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
6522 /* Lookup the char-table Vglyphless_char_display for character C (-1
6523 if we want information for no-font case), and return the display
6524 method symbol. By side-effect, update it->what and
6525 it->glyphless_method. This function is called from
6526 get_next_display_element for each character element, and from
6527 x_produce_glyphs when no suitable font was found. */
6530 lookup_glyphless_char_display (int c
, struct it
*it
)
6532 Lisp_Object glyphless_method
= Qnil
;
6534 if (CHAR_TABLE_P (Vglyphless_char_display
)
6535 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
)) >= 1)
6539 glyphless_method
= CHAR_TABLE_REF (Vglyphless_char_display
, c
);
6540 if (CONSP (glyphless_method
))
6541 glyphless_method
= FRAME_WINDOW_P (it
->f
)
6542 ? XCAR (glyphless_method
)
6543 : XCDR (glyphless_method
);
6546 glyphless_method
= XCHAR_TABLE (Vglyphless_char_display
)->extras
[0];
6550 if (NILP (glyphless_method
))
6553 /* The default is to display the character by a proper font. */
6555 /* The default for the no-font case is to display an empty box. */
6556 glyphless_method
= Qempty_box
;
6558 if (EQ (glyphless_method
, Qzero_width
))
6561 return glyphless_method
;
6562 /* This method can't be used for the no-font case. */
6563 glyphless_method
= Qempty_box
;
6565 if (EQ (glyphless_method
, Qthin_space
))
6566 it
->glyphless_method
= GLYPHLESS_DISPLAY_THIN_SPACE
;
6567 else if (EQ (glyphless_method
, Qempty_box
))
6568 it
->glyphless_method
= GLYPHLESS_DISPLAY_EMPTY_BOX
;
6569 else if (EQ (glyphless_method
, Qhex_code
))
6570 it
->glyphless_method
= GLYPHLESS_DISPLAY_HEX_CODE
;
6571 else if (STRINGP (glyphless_method
))
6572 it
->glyphless_method
= GLYPHLESS_DISPLAY_ACRONYM
;
6575 /* Invalid value. We use the default method. */
6576 glyphless_method
= Qnil
;
6579 it
->what
= IT_GLYPHLESS
;
6580 return glyphless_method
;
6583 /* Load IT's display element fields with information about the next
6584 display element from the current position of IT. Value is zero if
6585 end of buffer (or C string) is reached. */
6587 static struct frame
*last_escape_glyph_frame
= NULL
;
6588 static int last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
6589 static int last_escape_glyph_merged_face_id
= 0;
6591 struct frame
*last_glyphless_glyph_frame
= NULL
;
6592 int last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
6593 int last_glyphless_glyph_merged_face_id
= 0;
6596 get_next_display_element (struct it
*it
)
6598 /* Non-zero means that we found a display element. Zero means that
6599 we hit the end of what we iterate over. Performance note: the
6600 function pointer `method' used here turns out to be faster than
6601 using a sequence of if-statements. */
6605 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
6607 if (it
->what
== IT_CHARACTER
)
6609 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
6610 and only if (a) the resolved directionality of that character
6612 /* FIXME: Do we need an exception for characters from display
6614 if (it
->bidi_p
&& it
->bidi_it
.type
== STRONG_R
)
6615 it
->c
= bidi_mirror_char (it
->c
);
6616 /* Map via display table or translate control characters.
6617 IT->c, IT->len etc. have been set to the next character by
6618 the function call above. If we have a display table, and it
6619 contains an entry for IT->c, translate it. Don't do this if
6620 IT->c itself comes from a display table, otherwise we could
6621 end up in an infinite recursion. (An alternative could be to
6622 count the recursion depth of this function and signal an
6623 error when a certain maximum depth is reached.) Is it worth
6625 if (success_p
&& it
->dpvec
== NULL
)
6628 struct charset
*unibyte
= CHARSET_FROM_ID (charset_unibyte
);
6629 int nonascii_space_p
= 0;
6630 int nonascii_hyphen_p
= 0;
6631 int c
= it
->c
; /* This is the character to display. */
6633 if (! it
->multibyte_p
&& ! ASCII_CHAR_P (c
))
6635 eassert (SINGLE_BYTE_CHAR_P (c
));
6636 if (unibyte_display_via_language_environment
)
6638 c
= DECODE_CHAR (unibyte
, c
);
6640 c
= BYTE8_TO_CHAR (it
->c
);
6643 c
= BYTE8_TO_CHAR (it
->c
);
6647 && (dv
= DISP_CHAR_VECTOR (it
->dp
, c
),
6650 struct Lisp_Vector
*v
= XVECTOR (dv
);
6652 /* Return the first character from the display table
6653 entry, if not empty. If empty, don't display the
6654 current character. */
6657 it
->dpvec_char_len
= it
->len
;
6658 it
->dpvec
= v
->contents
;
6659 it
->dpend
= v
->contents
+ v
->header
.size
;
6660 it
->current
.dpvec_index
= 0;
6661 it
->dpvec_face_id
= -1;
6662 it
->saved_face_id
= it
->face_id
;
6663 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6668 set_iterator_to_next (it
, 0);
6673 if (! NILP (lookup_glyphless_char_display (c
, it
)))
6675 if (it
->what
== IT_GLYPHLESS
)
6677 /* Don't display this character. */
6678 set_iterator_to_next (it
, 0);
6682 /* If `nobreak-char-display' is non-nil, we display
6683 non-ASCII spaces and hyphens specially. */
6684 if (! ASCII_CHAR_P (c
) && ! NILP (Vnobreak_char_display
))
6687 nonascii_space_p
= 1;
6688 else if (c
== 0xAD || c
== 0x2010 || c
== 0x2011)
6689 nonascii_hyphen_p
= 1;
6692 /* Translate control characters into `\003' or `^C' form.
6693 Control characters coming from a display table entry are
6694 currently not translated because we use IT->dpvec to hold
6695 the translation. This could easily be changed but I
6696 don't believe that it is worth doing.
6698 The characters handled by `nobreak-char-display' must be
6701 Non-printable characters and raw-byte characters are also
6702 translated to octal form. */
6703 if (((c
< ' ' || c
== 127) /* ASCII control chars */
6704 ? (it
->area
!= TEXT_AREA
6705 /* In mode line, treat \n, \t like other crl chars. */
6708 && (it
->glyph_row
->mode_line_p
|| it
->avoid_cursor_p
))
6709 || (c
!= '\n' && c
!= '\t'))
6711 || nonascii_hyphen_p
6713 || ! CHAR_PRINTABLE_P (c
))))
6715 /* C is a control character, non-ASCII space/hyphen,
6716 raw-byte, or a non-printable character which must be
6717 displayed either as '\003' or as `^C' where the '\\'
6718 and '^' can be defined in the display table. Fill
6719 IT->ctl_chars with glyphs for what we have to
6720 display. Then, set IT->dpvec to these glyphs. */
6727 /* Handle control characters with ^. */
6729 if (ASCII_CHAR_P (c
) && it
->ctl_arrow_p
)
6733 g
= '^'; /* default glyph for Control */
6734 /* Set IT->ctl_chars[0] to the glyph for `^'. */
6736 && (gc
= DISP_CTRL_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
6738 g
= GLYPH_CODE_CHAR (gc
);
6739 lface_id
= GLYPH_CODE_FACE (gc
);
6743 face_id
= merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
);
6745 else if (it
->f
== last_escape_glyph_frame
6746 && it
->face_id
== last_escape_glyph_face_id
)
6748 face_id
= last_escape_glyph_merged_face_id
;
6752 /* Merge the escape-glyph face into the current face. */
6753 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6755 last_escape_glyph_frame
= it
->f
;
6756 last_escape_glyph_face_id
= it
->face_id
;
6757 last_escape_glyph_merged_face_id
= face_id
;
6760 XSETINT (it
->ctl_chars
[0], g
);
6761 XSETINT (it
->ctl_chars
[1], c
^ 0100);
6763 goto display_control
;
6766 /* Handle non-ascii space in the mode where it only gets
6769 if (nonascii_space_p
&& EQ (Vnobreak_char_display
, Qt
))
6771 /* Merge `nobreak-space' into the current face. */
6772 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
6774 XSETINT (it
->ctl_chars
[0], ' ');
6776 goto display_control
;
6779 /* Handle sequences that start with the "escape glyph". */
6781 /* the default escape glyph is \. */
6782 escape_glyph
= '\\';
6785 && (gc
= DISP_ESCAPE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
6787 escape_glyph
= GLYPH_CODE_CHAR (gc
);
6788 lface_id
= GLYPH_CODE_FACE (gc
);
6792 /* The display table specified a face.
6793 Merge it into face_id and also into escape_glyph. */
6794 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6797 else if (it
->f
== last_escape_glyph_frame
6798 && it
->face_id
== last_escape_glyph_face_id
)
6800 face_id
= last_escape_glyph_merged_face_id
;
6804 /* Merge the escape-glyph face into the current face. */
6805 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6807 last_escape_glyph_frame
= it
->f
;
6808 last_escape_glyph_face_id
= it
->face_id
;
6809 last_escape_glyph_merged_face_id
= face_id
;
6812 /* Draw non-ASCII hyphen with just highlighting: */
6814 if (nonascii_hyphen_p
&& EQ (Vnobreak_char_display
, Qt
))
6816 XSETINT (it
->ctl_chars
[0], '-');
6818 goto display_control
;
6821 /* Draw non-ASCII space/hyphen with escape glyph: */
6823 if (nonascii_space_p
|| nonascii_hyphen_p
)
6825 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6826 XSETINT (it
->ctl_chars
[1], nonascii_space_p
? ' ' : '-');
6828 goto display_control
;
6835 if (CHAR_BYTE8_P (c
))
6836 /* Display \200 instead of \17777600. */
6837 c
= CHAR_TO_BYTE8 (c
);
6838 len
= sprintf (str
, "%03o", c
);
6840 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6841 for (i
= 0; i
< len
; i
++)
6842 XSETINT (it
->ctl_chars
[i
+ 1], str
[i
]);
6847 /* Set up IT->dpvec and return first character from it. */
6848 it
->dpvec_char_len
= it
->len
;
6849 it
->dpvec
= it
->ctl_chars
;
6850 it
->dpend
= it
->dpvec
+ ctl_len
;
6851 it
->current
.dpvec_index
= 0;
6852 it
->dpvec_face_id
= face_id
;
6853 it
->saved_face_id
= it
->face_id
;
6854 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6858 it
->char_to_display
= c
;
6862 it
->char_to_display
= it
->c
;
6866 /* Adjust face id for a multibyte character. There are no multibyte
6867 character in unibyte text. */
6868 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
6871 && FRAME_WINDOW_P (it
->f
))
6873 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
6875 if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
>= 0)
6877 /* Automatic composition with glyph-string. */
6878 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
6880 it
->face_id
= face_for_font (it
->f
, LGSTRING_FONT (gstring
), face
);
6884 ptrdiff_t pos
= (it
->s
? -1
6885 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
6886 : IT_CHARPOS (*it
));
6889 if (it
->what
== IT_CHARACTER
)
6890 c
= it
->char_to_display
;
6893 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
6897 for (i
= 0; i
< cmp
->glyph_len
; i
++)
6898 /* TAB in a composition means display glyphs with
6899 padding space on the left or right. */
6900 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
6903 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, pos
, it
->string
);
6908 /* Is this character the last one of a run of characters with
6909 box? If yes, set IT->end_of_box_run_p to 1. */
6913 if (it
->method
== GET_FROM_STRING
&& it
->sp
)
6915 int face_id
= underlying_face_id (it
);
6916 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
6920 if (face
->box
== FACE_NO_BOX
)
6922 /* If the box comes from face properties in a
6923 display string, check faces in that string. */
6924 int string_face_id
= face_after_it_pos (it
);
6925 it
->end_of_box_run_p
6926 = (FACE_FROM_ID (it
->f
, string_face_id
)->box
6929 /* Otherwise, the box comes from the underlying face.
6930 If this is the last string character displayed, check
6931 the next buffer location. */
6932 else if ((IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
) - 1)
6933 && (it
->current
.overlay_string_index
6934 == it
->n_overlay_strings
- 1))
6938 struct text_pos pos
= it
->current
.pos
;
6939 INC_TEXT_POS (pos
, it
->multibyte_p
);
6941 next_face_id
= face_at_buffer_position
6942 (it
->w
, CHARPOS (pos
), it
->region_beg_charpos
,
6943 it
->region_end_charpos
, &ignore
,
6944 (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
), 0,
6946 it
->end_of_box_run_p
6947 = (FACE_FROM_ID (it
->f
, next_face_id
)->box
6954 int face_id
= face_after_it_pos (it
);
6955 it
->end_of_box_run_p
6956 = (face_id
!= it
->face_id
6957 && FACE_FROM_ID (it
->f
, face_id
)->box
== FACE_NO_BOX
);
6960 /* If we reached the end of the object we've been iterating (e.g., a
6961 display string or an overlay string), and there's something on
6962 IT->stack, proceed with what's on the stack. It doesn't make
6963 sense to return zero if there's unprocessed stuff on the stack,
6964 because otherwise that stuff will never be displayed. */
6965 if (!success_p
&& it
->sp
> 0)
6967 set_iterator_to_next (it
, 0);
6968 success_p
= get_next_display_element (it
);
6971 /* Value is 0 if end of buffer or string reached. */
6976 /* Move IT to the next display element.
6978 RESEAT_P non-zero means if called on a newline in buffer text,
6979 skip to the next visible line start.
6981 Functions get_next_display_element and set_iterator_to_next are
6982 separate because I find this arrangement easier to handle than a
6983 get_next_display_element function that also increments IT's
6984 position. The way it is we can first look at an iterator's current
6985 display element, decide whether it fits on a line, and if it does,
6986 increment the iterator position. The other way around we probably
6987 would either need a flag indicating whether the iterator has to be
6988 incremented the next time, or we would have to implement a
6989 decrement position function which would not be easy to write. */
6992 set_iterator_to_next (struct it
*it
, int reseat_p
)
6994 /* Reset flags indicating start and end of a sequence of characters
6995 with box. Reset them at the start of this function because
6996 moving the iterator to a new position might set them. */
6997 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
7001 case GET_FROM_BUFFER
:
7002 /* The current display element of IT is a character from
7003 current_buffer. Advance in the buffer, and maybe skip over
7004 invisible lines that are so because of selective display. */
7005 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
7006 reseat_at_next_visible_line_start (it
, 0);
7007 else if (it
->cmp_it
.id
>= 0)
7009 /* We are currently getting glyphs from a composition. */
7014 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7015 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7016 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7018 it
->cmp_it
.from
= it
->cmp_it
.to
;
7023 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7025 it
->end_charpos
, Qnil
);
7028 else if (! it
->cmp_it
.reversed_p
)
7030 /* Composition created while scanning forward. */
7031 /* Update IT's char/byte positions to point to the first
7032 character of the next grapheme cluster, or to the
7033 character visually after the current composition. */
7034 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7035 bidi_move_to_visually_next (&it
->bidi_it
);
7036 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7037 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7039 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7041 /* Proceed to the next grapheme cluster. */
7042 it
->cmp_it
.from
= it
->cmp_it
.to
;
7046 /* No more grapheme clusters in this composition.
7047 Find the next stop position. */
7048 ptrdiff_t stop
= it
->end_charpos
;
7049 if (it
->bidi_it
.scan_dir
< 0)
7050 /* Now we are scanning backward and don't know
7053 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7054 IT_BYTEPOS (*it
), stop
, Qnil
);
7059 /* Composition created while scanning backward. */
7060 /* Update IT's char/byte positions to point to the last
7061 character of the previous grapheme cluster, or the
7062 character visually after the current composition. */
7063 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7064 bidi_move_to_visually_next (&it
->bidi_it
);
7065 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7066 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7067 if (it
->cmp_it
.from
> 0)
7069 /* Proceed to the previous grapheme cluster. */
7070 it
->cmp_it
.to
= it
->cmp_it
.from
;
7074 /* No more grapheme clusters in this composition.
7075 Find the next stop position. */
7076 ptrdiff_t stop
= it
->end_charpos
;
7077 if (it
->bidi_it
.scan_dir
< 0)
7078 /* Now we are scanning backward and don't know
7081 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7082 IT_BYTEPOS (*it
), stop
, Qnil
);
7088 eassert (it
->len
!= 0);
7092 IT_BYTEPOS (*it
) += it
->len
;
7093 IT_CHARPOS (*it
) += 1;
7097 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7098 /* If this is a new paragraph, determine its base
7099 direction (a.k.a. its base embedding level). */
7100 if (it
->bidi_it
.new_paragraph
)
7101 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
7102 bidi_move_to_visually_next (&it
->bidi_it
);
7103 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7104 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7105 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7107 /* As the scan direction was changed, we must
7108 re-compute the stop position for composition. */
7109 ptrdiff_t stop
= it
->end_charpos
;
7110 if (it
->bidi_it
.scan_dir
< 0)
7112 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
7113 IT_BYTEPOS (*it
), stop
, Qnil
);
7116 eassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
7120 case GET_FROM_C_STRING
:
7121 /* Current display element of IT is from a C string. */
7123 /* If the string position is beyond string's end, it means
7124 next_element_from_c_string is padding the string with
7125 blanks, in which case we bypass the bidi iterator,
7126 because it cannot deal with such virtual characters. */
7127 || IT_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7129 IT_BYTEPOS (*it
) += it
->len
;
7130 IT_CHARPOS (*it
) += 1;
7134 bidi_move_to_visually_next (&it
->bidi_it
);
7135 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7136 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7140 case GET_FROM_DISPLAY_VECTOR
:
7141 /* Current display element of IT is from a display table entry.
7142 Advance in the display table definition. Reset it to null if
7143 end reached, and continue with characters from buffers/
7145 ++it
->current
.dpvec_index
;
7147 /* Restore face of the iterator to what they were before the
7148 display vector entry (these entries may contain faces). */
7149 it
->face_id
= it
->saved_face_id
;
7151 if (it
->dpvec
+ it
->current
.dpvec_index
>= it
->dpend
)
7153 int recheck_faces
= it
->ellipsis_p
;
7156 it
->method
= GET_FROM_C_STRING
;
7157 else if (STRINGP (it
->string
))
7158 it
->method
= GET_FROM_STRING
;
7161 it
->method
= GET_FROM_BUFFER
;
7162 it
->object
= it
->w
->buffer
;
7166 it
->current
.dpvec_index
= -1;
7168 /* Skip over characters which were displayed via IT->dpvec. */
7169 if (it
->dpvec_char_len
< 0)
7170 reseat_at_next_visible_line_start (it
, 1);
7171 else if (it
->dpvec_char_len
> 0)
7173 if (it
->method
== GET_FROM_STRING
7174 && it
->n_overlay_strings
> 0)
7175 it
->ignore_overlay_strings_at_pos_p
= 1;
7176 it
->len
= it
->dpvec_char_len
;
7177 set_iterator_to_next (it
, reseat_p
);
7180 /* Maybe recheck faces after display vector */
7182 it
->stop_charpos
= IT_CHARPOS (*it
);
7186 case GET_FROM_STRING
:
7187 /* Current display element is a character from a Lisp string. */
7188 eassert (it
->s
== NULL
&& STRINGP (it
->string
));
7189 /* Don't advance past string end. These conditions are true
7190 when set_iterator_to_next is called at the end of
7191 get_next_display_element, in which case the Lisp string is
7192 already exhausted, and all we want is pop the iterator
7194 if (it
->current
.overlay_string_index
>= 0)
7196 /* This is an overlay string, so there's no padding with
7197 spaces, and the number of characters in the string is
7198 where the string ends. */
7199 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7200 goto consider_string_end
;
7204 /* Not an overlay string. There could be padding, so test
7205 against it->end_charpos . */
7206 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7207 goto consider_string_end
;
7209 if (it
->cmp_it
.id
>= 0)
7215 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7216 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7217 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7218 it
->cmp_it
.from
= it
->cmp_it
.to
;
7222 composition_compute_stop_pos (&it
->cmp_it
,
7223 IT_STRING_CHARPOS (*it
),
7224 IT_STRING_BYTEPOS (*it
),
7225 it
->end_charpos
, it
->string
);
7228 else if (! it
->cmp_it
.reversed_p
)
7230 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7231 bidi_move_to_visually_next (&it
->bidi_it
);
7232 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7233 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7235 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
7236 it
->cmp_it
.from
= it
->cmp_it
.to
;
7239 ptrdiff_t stop
= it
->end_charpos
;
7240 if (it
->bidi_it
.scan_dir
< 0)
7242 composition_compute_stop_pos (&it
->cmp_it
,
7243 IT_STRING_CHARPOS (*it
),
7244 IT_STRING_BYTEPOS (*it
), stop
,
7250 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
7251 bidi_move_to_visually_next (&it
->bidi_it
);
7252 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7253 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7254 if (it
->cmp_it
.from
> 0)
7255 it
->cmp_it
.to
= it
->cmp_it
.from
;
7258 ptrdiff_t stop
= it
->end_charpos
;
7259 if (it
->bidi_it
.scan_dir
< 0)
7261 composition_compute_stop_pos (&it
->cmp_it
,
7262 IT_STRING_CHARPOS (*it
),
7263 IT_STRING_BYTEPOS (*it
), stop
,
7271 /* If the string position is beyond string's end, it
7272 means next_element_from_string is padding the string
7273 with blanks, in which case we bypass the bidi
7274 iterator, because it cannot deal with such virtual
7276 || IT_STRING_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
7278 IT_STRING_BYTEPOS (*it
) += it
->len
;
7279 IT_STRING_CHARPOS (*it
) += 1;
7283 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
7285 bidi_move_to_visually_next (&it
->bidi_it
);
7286 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7287 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7288 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
7290 ptrdiff_t stop
= it
->end_charpos
;
7292 if (it
->bidi_it
.scan_dir
< 0)
7294 composition_compute_stop_pos (&it
->cmp_it
,
7295 IT_STRING_CHARPOS (*it
),
7296 IT_STRING_BYTEPOS (*it
), stop
,
7302 consider_string_end
:
7304 if (it
->current
.overlay_string_index
>= 0)
7306 /* IT->string is an overlay string. Advance to the
7307 next, if there is one. */
7308 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7311 next_overlay_string (it
);
7313 setup_for_ellipsis (it
, 0);
7318 /* IT->string is not an overlay string. If we reached
7319 its end, and there is something on IT->stack, proceed
7320 with what is on the stack. This can be either another
7321 string, this time an overlay string, or a buffer. */
7322 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
7326 if (it
->method
== GET_FROM_STRING
)
7327 goto consider_string_end
;
7332 case GET_FROM_IMAGE
:
7333 case GET_FROM_STRETCH
:
7334 /* The position etc with which we have to proceed are on
7335 the stack. The position may be at the end of a string,
7336 if the `display' property takes up the whole string. */
7337 eassert (it
->sp
> 0);
7339 if (it
->method
== GET_FROM_STRING
)
7340 goto consider_string_end
;
7344 /* There are no other methods defined, so this should be a bug. */
7348 eassert (it
->method
!= GET_FROM_STRING
7349 || (STRINGP (it
->string
)
7350 && IT_STRING_CHARPOS (*it
) >= 0));
7353 /* Load IT's display element fields with information about the next
7354 display element which comes from a display table entry or from the
7355 result of translating a control character to one of the forms `^C'
7358 IT->dpvec holds the glyphs to return as characters.
7359 IT->saved_face_id holds the face id before the display vector--it
7360 is restored into IT->face_id in set_iterator_to_next. */
7363 next_element_from_display_vector (struct it
*it
)
7368 eassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
7370 it
->face_id
= it
->saved_face_id
;
7372 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
7373 That seemed totally bogus - so I changed it... */
7374 gc
= it
->dpvec
[it
->current
.dpvec_index
];
7376 if (GLYPH_CODE_P (gc
))
7378 it
->c
= GLYPH_CODE_CHAR (gc
);
7379 it
->len
= CHAR_BYTES (it
->c
);
7381 /* The entry may contain a face id to use. Such a face id is
7382 the id of a Lisp face, not a realized face. A face id of
7383 zero means no face is specified. */
7384 if (it
->dpvec_face_id
>= 0)
7385 it
->face_id
= it
->dpvec_face_id
;
7388 int lface_id
= GLYPH_CODE_FACE (gc
);
7390 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
7395 /* Display table entry is invalid. Return a space. */
7396 it
->c
= ' ', it
->len
= 1;
7398 /* Don't change position and object of the iterator here. They are
7399 still the values of the character that had this display table
7400 entry or was translated, and that's what we want. */
7401 it
->what
= IT_CHARACTER
;
7405 /* Get the first element of string/buffer in the visual order, after
7406 being reseated to a new position in a string or a buffer. */
7408 get_visually_first_element (struct it
*it
)
7410 int string_p
= STRINGP (it
->string
) || it
->s
;
7411 ptrdiff_t eob
= (string_p
? it
->bidi_it
.string
.schars
: ZV
);
7412 ptrdiff_t bob
= (string_p
? 0 : BEGV
);
7414 if (STRINGP (it
->string
))
7416 it
->bidi_it
.charpos
= IT_STRING_CHARPOS (*it
);
7417 it
->bidi_it
.bytepos
= IT_STRING_BYTEPOS (*it
);
7421 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
7422 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
7425 if (it
->bidi_it
.charpos
== eob
)
7427 /* Nothing to do, but reset the FIRST_ELT flag, like
7428 bidi_paragraph_init does, because we are not going to
7430 it
->bidi_it
.first_elt
= 0;
7432 else if (it
->bidi_it
.charpos
== bob
7434 && (FETCH_CHAR (it
->bidi_it
.bytepos
- 1) == '\n'
7435 || FETCH_CHAR (it
->bidi_it
.bytepos
) == '\n')))
7437 /* If we are at the beginning of a line/string, we can produce
7438 the next element right away. */
7439 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7440 bidi_move_to_visually_next (&it
->bidi_it
);
7444 ptrdiff_t orig_bytepos
= it
->bidi_it
.bytepos
;
7446 /* We need to prime the bidi iterator starting at the line's or
7447 string's beginning, before we will be able to produce the
7450 it
->bidi_it
.charpos
= it
->bidi_it
.bytepos
= 0;
7453 it
->bidi_it
.charpos
= find_next_newline_no_quit (IT_CHARPOS (*it
),
7455 it
->bidi_it
.bytepos
= CHAR_TO_BYTE (it
->bidi_it
.charpos
);
7457 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
7460 /* Now return to buffer/string position where we were asked
7461 to get the next display element, and produce that. */
7462 bidi_move_to_visually_next (&it
->bidi_it
);
7464 while (it
->bidi_it
.bytepos
!= orig_bytepos
7465 && it
->bidi_it
.charpos
< eob
);
7468 /* Adjust IT's position information to where we ended up. */
7469 if (STRINGP (it
->string
))
7471 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7472 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7476 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
7477 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
7480 if (STRINGP (it
->string
) || !it
->s
)
7482 ptrdiff_t stop
, charpos
, bytepos
;
7484 if (STRINGP (it
->string
))
7487 stop
= SCHARS (it
->string
);
7488 if (stop
> it
->end_charpos
)
7489 stop
= it
->end_charpos
;
7490 charpos
= IT_STRING_CHARPOS (*it
);
7491 bytepos
= IT_STRING_BYTEPOS (*it
);
7495 stop
= it
->end_charpos
;
7496 charpos
= IT_CHARPOS (*it
);
7497 bytepos
= IT_BYTEPOS (*it
);
7499 if (it
->bidi_it
.scan_dir
< 0)
7501 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
, stop
,
7506 /* Load IT with the next display element from Lisp string IT->string.
7507 IT->current.string_pos is the current position within the string.
7508 If IT->current.overlay_string_index >= 0, the Lisp string is an
7512 next_element_from_string (struct it
*it
)
7514 struct text_pos position
;
7516 eassert (STRINGP (it
->string
));
7517 eassert (!it
->bidi_p
|| EQ (it
->string
, it
->bidi_it
.string
.lstring
));
7518 eassert (IT_STRING_CHARPOS (*it
) >= 0);
7519 position
= it
->current
.string_pos
;
7521 /* With bidi reordering, the character to display might not be the
7522 character at IT_STRING_CHARPOS. BIDI_IT.FIRST_ELT non-zero means
7523 that we were reseat()ed to a new string, whose paragraph
7524 direction is not known. */
7525 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7527 get_visually_first_element (it
);
7528 SET_TEXT_POS (position
, IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
));
7531 /* Time to check for invisible text? */
7532 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
7534 if (IT_STRING_CHARPOS (*it
) >= it
->stop_charpos
)
7537 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7538 || IT_STRING_CHARPOS (*it
) == it
->stop_charpos
))
7540 /* With bidi non-linear iteration, we could find
7541 ourselves far beyond the last computed stop_charpos,
7542 with several other stop positions in between that we
7543 missed. Scan them all now, in buffer's logical
7544 order, until we find and handle the last stop_charpos
7545 that precedes our current position. */
7546 handle_stop_backwards (it
, it
->stop_charpos
);
7547 return GET_NEXT_DISPLAY_ELEMENT (it
);
7553 /* Take note of the stop position we just moved
7554 across, for when we will move back across it. */
7555 it
->prev_stop
= it
->stop_charpos
;
7556 /* If we are at base paragraph embedding level, take
7557 note of the last stop position seen at this
7559 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7560 it
->base_level_stop
= it
->stop_charpos
;
7564 /* Since a handler may have changed IT->method, we must
7566 return GET_NEXT_DISPLAY_ELEMENT (it
);
7570 /* If we are before prev_stop, we may have overstepped
7571 on our way backwards a stop_pos, and if so, we need
7572 to handle that stop_pos. */
7573 && IT_STRING_CHARPOS (*it
) < it
->prev_stop
7574 /* We can sometimes back up for reasons that have nothing
7575 to do with bidi reordering. E.g., compositions. The
7576 code below is only needed when we are above the base
7577 embedding level, so test for that explicitly. */
7578 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7580 /* If we lost track of base_level_stop, we have no better
7581 place for handle_stop_backwards to start from than string
7582 beginning. This happens, e.g., when we were reseated to
7583 the previous screenful of text by vertical-motion. */
7584 if (it
->base_level_stop
<= 0
7585 || IT_STRING_CHARPOS (*it
) < it
->base_level_stop
)
7586 it
->base_level_stop
= 0;
7587 handle_stop_backwards (it
, it
->base_level_stop
);
7588 return GET_NEXT_DISPLAY_ELEMENT (it
);
7592 if (it
->current
.overlay_string_index
>= 0)
7594 /* Get the next character from an overlay string. In overlay
7595 strings, there is no field width or padding with spaces to
7597 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7602 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7603 IT_STRING_BYTEPOS (*it
),
7604 it
->bidi_it
.scan_dir
< 0
7606 : SCHARS (it
->string
))
7607 && next_element_from_composition (it
))
7611 else if (STRING_MULTIBYTE (it
->string
))
7613 const unsigned char *s
= (SDATA (it
->string
)
7614 + IT_STRING_BYTEPOS (*it
));
7615 it
->c
= string_char_and_length (s
, &it
->len
);
7619 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7625 /* Get the next character from a Lisp string that is not an
7626 overlay string. Such strings come from the mode line, for
7627 example. We may have to pad with spaces, or truncate the
7628 string. See also next_element_from_c_string. */
7629 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7634 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
7636 /* Pad with spaces. */
7637 it
->c
= ' ', it
->len
= 1;
7638 CHARPOS (position
) = BYTEPOS (position
) = -1;
7640 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7641 IT_STRING_BYTEPOS (*it
),
7642 it
->bidi_it
.scan_dir
< 0
7644 : it
->string_nchars
)
7645 && next_element_from_composition (it
))
7649 else if (STRING_MULTIBYTE (it
->string
))
7651 const unsigned char *s
= (SDATA (it
->string
)
7652 + IT_STRING_BYTEPOS (*it
));
7653 it
->c
= string_char_and_length (s
, &it
->len
);
7657 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7662 /* Record what we have and where it came from. */
7663 it
->what
= IT_CHARACTER
;
7664 it
->object
= it
->string
;
7665 it
->position
= position
;
7670 /* Load IT with next display element from C string IT->s.
7671 IT->string_nchars is the maximum number of characters to return
7672 from the string. IT->end_charpos may be greater than
7673 IT->string_nchars when this function is called, in which case we
7674 may have to return padding spaces. Value is zero if end of string
7675 reached, including padding spaces. */
7678 next_element_from_c_string (struct it
*it
)
7683 eassert (!it
->bidi_p
|| it
->s
== it
->bidi_it
.string
.s
);
7684 it
->what
= IT_CHARACTER
;
7685 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
7688 /* With bidi reordering, the character to display might not be the
7689 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7690 we were reseated to a new string, whose paragraph direction is
7692 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7693 get_visually_first_element (it
);
7695 /* IT's position can be greater than IT->string_nchars in case a
7696 field width or precision has been specified when the iterator was
7698 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7700 /* End of the game. */
7704 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
7706 /* Pad with spaces. */
7707 it
->c
= ' ', it
->len
= 1;
7708 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
7710 else if (it
->multibyte_p
)
7711 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
), &it
->len
);
7713 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
7719 /* Set up IT to return characters from an ellipsis, if appropriate.
7720 The definition of the ellipsis glyphs may come from a display table
7721 entry. This function fills IT with the first glyph from the
7722 ellipsis if an ellipsis is to be displayed. */
7725 next_element_from_ellipsis (struct it
*it
)
7727 if (it
->selective_display_ellipsis_p
)
7728 setup_for_ellipsis (it
, it
->len
);
7731 /* The face at the current position may be different from the
7732 face we find after the invisible text. Remember what it
7733 was in IT->saved_face_id, and signal that it's there by
7734 setting face_before_selective_p. */
7735 it
->saved_face_id
= it
->face_id
;
7736 it
->method
= GET_FROM_BUFFER
;
7737 it
->object
= it
->w
->buffer
;
7738 reseat_at_next_visible_line_start (it
, 1);
7739 it
->face_before_selective_p
= 1;
7742 return GET_NEXT_DISPLAY_ELEMENT (it
);
7746 /* Deliver an image display element. The iterator IT is already
7747 filled with image information (done in handle_display_prop). Value
7752 next_element_from_image (struct it
*it
)
7754 it
->what
= IT_IMAGE
;
7755 it
->ignore_overlay_strings_at_pos_p
= 0;
7760 /* Fill iterator IT with next display element from a stretch glyph
7761 property. IT->object is the value of the text property. Value is
7765 next_element_from_stretch (struct it
*it
)
7767 it
->what
= IT_STRETCH
;
7771 /* Scan backwards from IT's current position until we find a stop
7772 position, or until BEGV. This is called when we find ourself
7773 before both the last known prev_stop and base_level_stop while
7774 reordering bidirectional text. */
7777 compute_stop_pos_backwards (struct it
*it
)
7779 const int SCAN_BACK_LIMIT
= 1000;
7780 struct text_pos pos
;
7781 struct display_pos save_current
= it
->current
;
7782 struct text_pos save_position
= it
->position
;
7783 ptrdiff_t charpos
= IT_CHARPOS (*it
);
7784 ptrdiff_t where_we_are
= charpos
;
7785 ptrdiff_t save_stop_pos
= it
->stop_charpos
;
7786 ptrdiff_t save_end_pos
= it
->end_charpos
;
7788 eassert (NILP (it
->string
) && !it
->s
);
7789 eassert (it
->bidi_p
);
7793 it
->end_charpos
= min (charpos
+ 1, ZV
);
7794 charpos
= max (charpos
- SCAN_BACK_LIMIT
, BEGV
);
7795 SET_TEXT_POS (pos
, charpos
, CHAR_TO_BYTE (charpos
));
7796 reseat_1 (it
, pos
, 0);
7797 compute_stop_pos (it
);
7798 /* We must advance forward, right? */
7799 if (it
->stop_charpos
<= charpos
)
7802 while (charpos
> BEGV
&& it
->stop_charpos
>= it
->end_charpos
);
7804 if (it
->stop_charpos
<= where_we_are
)
7805 it
->prev_stop
= it
->stop_charpos
;
7807 it
->prev_stop
= BEGV
;
7809 it
->current
= save_current
;
7810 it
->position
= save_position
;
7811 it
->stop_charpos
= save_stop_pos
;
7812 it
->end_charpos
= save_end_pos
;
7815 /* Scan forward from CHARPOS in the current buffer/string, until we
7816 find a stop position > current IT's position. Then handle the stop
7817 position before that. This is called when we bump into a stop
7818 position while reordering bidirectional text. CHARPOS should be
7819 the last previously processed stop_pos (or BEGV/0, if none were
7820 processed yet) whose position is less that IT's current
7824 handle_stop_backwards (struct it
*it
, ptrdiff_t charpos
)
7826 int bufp
= !STRINGP (it
->string
);
7827 ptrdiff_t where_we_are
= (bufp
? IT_CHARPOS (*it
) : IT_STRING_CHARPOS (*it
));
7828 struct display_pos save_current
= it
->current
;
7829 struct text_pos save_position
= it
->position
;
7830 struct text_pos pos1
;
7831 ptrdiff_t next_stop
;
7833 /* Scan in strict logical order. */
7834 eassert (it
->bidi_p
);
7838 it
->prev_stop
= charpos
;
7841 SET_TEXT_POS (pos1
, charpos
, CHAR_TO_BYTE (charpos
));
7842 reseat_1 (it
, pos1
, 0);
7845 it
->current
.string_pos
= string_pos (charpos
, it
->string
);
7846 compute_stop_pos (it
);
7847 /* We must advance forward, right? */
7848 if (it
->stop_charpos
<= it
->prev_stop
)
7850 charpos
= it
->stop_charpos
;
7852 while (charpos
<= where_we_are
);
7855 it
->current
= save_current
;
7856 it
->position
= save_position
;
7857 next_stop
= it
->stop_charpos
;
7858 it
->stop_charpos
= it
->prev_stop
;
7860 it
->stop_charpos
= next_stop
;
7863 /* Load IT with the next display element from current_buffer. Value
7864 is zero if end of buffer reached. IT->stop_charpos is the next
7865 position at which to stop and check for text properties or buffer
7869 next_element_from_buffer (struct it
*it
)
7873 eassert (IT_CHARPOS (*it
) >= BEGV
);
7874 eassert (NILP (it
->string
) && !it
->s
);
7875 eassert (!it
->bidi_p
7876 || (EQ (it
->bidi_it
.string
.lstring
, Qnil
)
7877 && it
->bidi_it
.string
.s
== NULL
));
7879 /* With bidi reordering, the character to display might not be the
7880 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7881 we were reseat()ed to a new buffer position, which is potentially
7882 a different paragraph. */
7883 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7885 get_visually_first_element (it
);
7886 SET_TEXT_POS (it
->position
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7889 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
7891 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7893 int overlay_strings_follow_p
;
7895 /* End of the game, except when overlay strings follow that
7896 haven't been returned yet. */
7897 if (it
->overlay_strings_at_end_processed_p
)
7898 overlay_strings_follow_p
= 0;
7901 it
->overlay_strings_at_end_processed_p
= 1;
7902 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
7905 if (overlay_strings_follow_p
)
7906 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
7910 it
->position
= it
->current
.pos
;
7914 else if (!(!it
->bidi_p
7915 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7916 || IT_CHARPOS (*it
) == it
->stop_charpos
))
7918 /* With bidi non-linear iteration, we could find ourselves
7919 far beyond the last computed stop_charpos, with several
7920 other stop positions in between that we missed. Scan
7921 them all now, in buffer's logical order, until we find
7922 and handle the last stop_charpos that precedes our
7923 current position. */
7924 handle_stop_backwards (it
, it
->stop_charpos
);
7925 return GET_NEXT_DISPLAY_ELEMENT (it
);
7931 /* Take note of the stop position we just moved across,
7932 for when we will move back across it. */
7933 it
->prev_stop
= it
->stop_charpos
;
7934 /* If we are at base paragraph embedding level, take
7935 note of the last stop position seen at this
7937 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7938 it
->base_level_stop
= it
->stop_charpos
;
7941 return GET_NEXT_DISPLAY_ELEMENT (it
);
7945 /* If we are before prev_stop, we may have overstepped on
7946 our way backwards a stop_pos, and if so, we need to
7947 handle that stop_pos. */
7948 && IT_CHARPOS (*it
) < it
->prev_stop
7949 /* We can sometimes back up for reasons that have nothing
7950 to do with bidi reordering. E.g., compositions. The
7951 code below is only needed when we are above the base
7952 embedding level, so test for that explicitly. */
7953 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7955 if (it
->base_level_stop
<= 0
7956 || IT_CHARPOS (*it
) < it
->base_level_stop
)
7958 /* If we lost track of base_level_stop, we need to find
7959 prev_stop by looking backwards. This happens, e.g., when
7960 we were reseated to the previous screenful of text by
7962 it
->base_level_stop
= BEGV
;
7963 compute_stop_pos_backwards (it
);
7964 handle_stop_backwards (it
, it
->prev_stop
);
7967 handle_stop_backwards (it
, it
->base_level_stop
);
7968 return GET_NEXT_DISPLAY_ELEMENT (it
);
7972 /* No face changes, overlays etc. in sight, so just return a
7973 character from current_buffer. */
7977 /* Maybe run the redisplay end trigger hook. Performance note:
7978 This doesn't seem to cost measurable time. */
7979 if (it
->redisplay_end_trigger_charpos
7981 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
7982 run_redisplay_end_trigger_hook (it
);
7984 stop
= it
->bidi_it
.scan_dir
< 0 ? -1 : it
->end_charpos
;
7985 if (CHAR_COMPOSED_P (it
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
7987 && next_element_from_composition (it
))
7992 /* Get the next character, maybe multibyte. */
7993 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
7994 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
7995 it
->c
= STRING_CHAR_AND_LENGTH (p
, it
->len
);
7997 it
->c
= *p
, it
->len
= 1;
7999 /* Record what we have and where it came from. */
8000 it
->what
= IT_CHARACTER
;
8001 it
->object
= it
->w
->buffer
;
8002 it
->position
= it
->current
.pos
;
8004 /* Normally we return the character found above, except when we
8005 really want to return an ellipsis for selective display. */
8010 /* A value of selective > 0 means hide lines indented more
8011 than that number of columns. */
8012 if (it
->selective
> 0
8013 && IT_CHARPOS (*it
) + 1 < ZV
8014 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
8015 IT_BYTEPOS (*it
) + 1,
8018 success_p
= next_element_from_ellipsis (it
);
8019 it
->dpvec_char_len
= -1;
8022 else if (it
->c
== '\r' && it
->selective
== -1)
8024 /* A value of selective == -1 means that everything from the
8025 CR to the end of the line is invisible, with maybe an
8026 ellipsis displayed for it. */
8027 success_p
= next_element_from_ellipsis (it
);
8028 it
->dpvec_char_len
= -1;
8033 /* Value is zero if end of buffer reached. */
8034 eassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
8039 /* Run the redisplay end trigger hook for IT. */
8042 run_redisplay_end_trigger_hook (struct it
*it
)
8044 Lisp_Object args
[3];
8046 /* IT->glyph_row should be non-null, i.e. we should be actually
8047 displaying something, or otherwise we should not run the hook. */
8048 eassert (it
->glyph_row
);
8050 /* Set up hook arguments. */
8051 args
[0] = Qredisplay_end_trigger_functions
;
8052 args
[1] = it
->window
;
8053 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
8054 it
->redisplay_end_trigger_charpos
= 0;
8056 /* Since we are *trying* to run these functions, don't try to run
8057 them again, even if they get an error. */
8058 wset_redisplay_end_trigger (it
->w
, Qnil
);
8059 Frun_hook_with_args (3, args
);
8061 /* Notice if it changed the face of the character we are on. */
8062 handle_face_prop (it
);
8066 /* Deliver a composition display element. Unlike the other
8067 next_element_from_XXX, this function is not registered in the array
8068 get_next_element[]. It is called from next_element_from_buffer and
8069 next_element_from_string when necessary. */
8072 next_element_from_composition (struct it
*it
)
8074 it
->what
= IT_COMPOSITION
;
8075 it
->len
= it
->cmp_it
.nbytes
;
8076 if (STRINGP (it
->string
))
8080 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8081 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8084 it
->position
= it
->current
.string_pos
;
8085 it
->object
= it
->string
;
8086 it
->c
= composition_update_it (&it
->cmp_it
, IT_STRING_CHARPOS (*it
),
8087 IT_STRING_BYTEPOS (*it
), it
->string
);
8093 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
8094 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
8097 if (it
->bidi_it
.new_paragraph
)
8098 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
8099 /* Resync the bidi iterator with IT's new position.
8100 FIXME: this doesn't support bidirectional text. */
8101 while (it
->bidi_it
.charpos
< IT_CHARPOS (*it
))
8102 bidi_move_to_visually_next (&it
->bidi_it
);
8106 it
->position
= it
->current
.pos
;
8107 it
->object
= it
->w
->buffer
;
8108 it
->c
= composition_update_it (&it
->cmp_it
, IT_CHARPOS (*it
),
8109 IT_BYTEPOS (*it
), Qnil
);
8116 /***********************************************************************
8117 Moving an iterator without producing glyphs
8118 ***********************************************************************/
8120 /* Check if iterator is at a position corresponding to a valid buffer
8121 position after some move_it_ call. */
8123 #define IT_POS_VALID_AFTER_MOVE_P(it) \
8124 ((it)->method == GET_FROM_STRING \
8125 ? IT_STRING_CHARPOS (*it) == 0 \
8129 /* Move iterator IT to a specified buffer or X position within one
8130 line on the display without producing glyphs.
8132 OP should be a bit mask including some or all of these bits:
8133 MOVE_TO_X: Stop upon reaching x-position TO_X.
8134 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
8135 Regardless of OP's value, stop upon reaching the end of the display line.
8137 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
8138 This means, in particular, that TO_X includes window's horizontal
8141 The return value has several possible values that
8142 say what condition caused the scan to stop:
8144 MOVE_POS_MATCH_OR_ZV
8145 - when TO_POS or ZV was reached.
8148 -when TO_X was reached before TO_POS or ZV were reached.
8151 - when we reached the end of the display area and the line must
8155 - when we reached the end of the display area and the line is
8159 - when we stopped at a line end, i.e. a newline or a CR and selective
8162 static enum move_it_result
8163 move_it_in_display_line_to (struct it
*it
,
8164 ptrdiff_t to_charpos
, int to_x
,
8165 enum move_operation_enum op
)
8167 enum move_it_result result
= MOVE_UNDEFINED
;
8168 struct glyph_row
*saved_glyph_row
;
8169 struct it wrap_it
, atpos_it
, atx_it
, ppos_it
;
8170 void *wrap_data
= NULL
, *atpos_data
= NULL
, *atx_data
= NULL
;
8171 void *ppos_data
= NULL
;
8173 enum it_method prev_method
= it
->method
;
8174 ptrdiff_t prev_pos
= IT_CHARPOS (*it
);
8175 int saw_smaller_pos
= prev_pos
< to_charpos
;
8177 /* Don't produce glyphs in produce_glyphs. */
8178 saved_glyph_row
= it
->glyph_row
;
8179 it
->glyph_row
= NULL
;
8181 /* Use wrap_it to save a copy of IT wherever a word wrap could
8182 occur. Use atpos_it to save a copy of IT at the desired buffer
8183 position, if found, so that we can scan ahead and check if the
8184 word later overshoots the window edge. Use atx_it similarly, for
8190 /* Use ppos_it under bidi reordering to save a copy of IT for the
8191 position > CHARPOS that is the closest to CHARPOS. We restore
8192 that position in IT when we have scanned the entire display line
8193 without finding a match for CHARPOS and all the character
8194 positions are greater than CHARPOS. */
8197 SAVE_IT (ppos_it
, *it
, ppos_data
);
8198 SET_TEXT_POS (ppos_it
.current
.pos
, ZV
, ZV_BYTE
);
8199 if ((op
& MOVE_TO_POS
) && IT_CHARPOS (*it
) >= to_charpos
)
8200 SAVE_IT (ppos_it
, *it
, ppos_data
);
8203 #define BUFFER_POS_REACHED_P() \
8204 ((op & MOVE_TO_POS) != 0 \
8205 && BUFFERP (it->object) \
8206 && (IT_CHARPOS (*it) == to_charpos \
8208 || BIDI_AT_BASE_LEVEL (it->bidi_it)) \
8209 && IT_CHARPOS (*it) > to_charpos) \
8210 || (it->what == IT_COMPOSITION \
8211 && ((IT_CHARPOS (*it) > to_charpos \
8212 && to_charpos >= it->cmp_it.charpos) \
8213 || (IT_CHARPOS (*it) < to_charpos \
8214 && to_charpos <= it->cmp_it.charpos)))) \
8215 && (it->method == GET_FROM_BUFFER \
8216 || (it->method == GET_FROM_DISPLAY_VECTOR \
8217 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
8219 /* If there's a line-/wrap-prefix, handle it. */
8220 if (it
->hpos
== 0 && it
->method
== GET_FROM_BUFFER
8221 && it
->current_y
< it
->last_visible_y
)
8222 handle_line_prefix (it
);
8224 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8225 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8229 int x
, i
, ascent
= 0, descent
= 0;
8231 /* Utility macro to reset an iterator with x, ascent, and descent. */
8232 #define IT_RESET_X_ASCENT_DESCENT(IT) \
8233 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
8234 (IT)->max_descent = descent)
8236 /* Stop if we move beyond TO_CHARPOS (after an image or a
8237 display string or stretch glyph). */
8238 if ((op
& MOVE_TO_POS
) != 0
8239 && BUFFERP (it
->object
)
8240 && it
->method
== GET_FROM_BUFFER
8242 /* When the iterator is at base embedding level, we
8243 are guaranteed that characters are delivered for
8244 display in strictly increasing order of their
8245 buffer positions. */
8246 || BIDI_AT_BASE_LEVEL (it
->bidi_it
))
8247 && IT_CHARPOS (*it
) > to_charpos
)
8249 && (prev_method
== GET_FROM_IMAGE
8250 || prev_method
== GET_FROM_STRETCH
8251 || prev_method
== GET_FROM_STRING
)
8252 /* Passed TO_CHARPOS from left to right. */
8253 && ((prev_pos
< to_charpos
8254 && IT_CHARPOS (*it
) > to_charpos
)
8255 /* Passed TO_CHARPOS from right to left. */
8256 || (prev_pos
> to_charpos
8257 && IT_CHARPOS (*it
) < to_charpos
)))))
8259 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8261 result
= MOVE_POS_MATCH_OR_ZV
;
8264 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8265 /* If wrap_it is valid, the current position might be in a
8266 word that is wrapped. So, save the iterator in
8267 atpos_it and continue to see if wrapping happens. */
8268 SAVE_IT (atpos_it
, *it
, atpos_data
);
8271 /* Stop when ZV reached.
8272 We used to stop here when TO_CHARPOS reached as well, but that is
8273 too soon if this glyph does not fit on this line. So we handle it
8274 explicitly below. */
8275 if (!get_next_display_element (it
))
8277 result
= MOVE_POS_MATCH_OR_ZV
;
8281 if (it
->line_wrap
== TRUNCATE
)
8283 if (BUFFER_POS_REACHED_P ())
8285 result
= MOVE_POS_MATCH_OR_ZV
;
8291 if (it
->line_wrap
== WORD_WRAP
)
8293 if (IT_DISPLAYING_WHITESPACE (it
))
8297 /* We have reached a glyph that follows one or more
8298 whitespace characters. If the position is
8299 already found, we are done. */
8300 if (atpos_it
.sp
>= 0)
8302 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8303 result
= MOVE_POS_MATCH_OR_ZV
;
8308 RESTORE_IT (it
, &atx_it
, atx_data
);
8309 result
= MOVE_X_REACHED
;
8312 /* Otherwise, we can wrap here. */
8313 SAVE_IT (wrap_it
, *it
, wrap_data
);
8319 /* Remember the line height for the current line, in case
8320 the next element doesn't fit on the line. */
8321 ascent
= it
->max_ascent
;
8322 descent
= it
->max_descent
;
8324 /* The call to produce_glyphs will get the metrics of the
8325 display element IT is loaded with. Record the x-position
8326 before this display element, in case it doesn't fit on the
8330 PRODUCE_GLYPHS (it
);
8332 if (it
->area
!= TEXT_AREA
)
8334 prev_method
= it
->method
;
8335 if (it
->method
== GET_FROM_BUFFER
)
8336 prev_pos
= IT_CHARPOS (*it
);
8337 set_iterator_to_next (it
, 1);
8338 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8339 SET_TEXT_POS (this_line_min_pos
,
8340 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8342 && (op
& MOVE_TO_POS
)
8343 && IT_CHARPOS (*it
) > to_charpos
8344 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
8345 SAVE_IT (ppos_it
, *it
, ppos_data
);
8349 /* The number of glyphs we get back in IT->nglyphs will normally
8350 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
8351 character on a terminal frame, or (iii) a line end. For the
8352 second case, IT->nglyphs - 1 padding glyphs will be present.
8353 (On X frames, there is only one glyph produced for a
8354 composite character.)
8356 The behavior implemented below means, for continuation lines,
8357 that as many spaces of a TAB as fit on the current line are
8358 displayed there. For terminal frames, as many glyphs of a
8359 multi-glyph character are displayed in the current line, too.
8360 This is what the old redisplay code did, and we keep it that
8361 way. Under X, the whole shape of a complex character must
8362 fit on the line or it will be completely displayed in the
8365 Note that both for tabs and padding glyphs, all glyphs have
8369 /* More than one glyph or glyph doesn't fit on line. All
8370 glyphs have the same width. */
8371 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
8373 int x_before_this_char
= x
;
8374 int hpos_before_this_char
= it
->hpos
;
8376 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
8378 new_x
= x
+ single_glyph_width
;
8380 /* We want to leave anything reaching TO_X to the caller. */
8381 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
8383 if (BUFFER_POS_REACHED_P ())
8385 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8386 goto buffer_pos_reached
;
8387 if (atpos_it
.sp
< 0)
8389 SAVE_IT (atpos_it
, *it
, atpos_data
);
8390 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8395 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8398 result
= MOVE_X_REACHED
;
8403 SAVE_IT (atx_it
, *it
, atx_data
);
8404 IT_RESET_X_ASCENT_DESCENT (&atx_it
);
8409 if (/* Lines are continued. */
8410 it
->line_wrap
!= TRUNCATE
8411 && (/* And glyph doesn't fit on the line. */
8412 new_x
> it
->last_visible_x
8413 /* Or it fits exactly and we're on a window
8415 || (new_x
== it
->last_visible_x
8416 && FRAME_WINDOW_P (it
->f
)
8417 && ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8418 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8419 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
8421 if (/* IT->hpos == 0 means the very first glyph
8422 doesn't fit on the line, e.g. a wide image. */
8424 || (new_x
== it
->last_visible_x
8425 && FRAME_WINDOW_P (it
->f
)))
8428 it
->current_x
= new_x
;
8430 /* The character's last glyph just barely fits
8432 if (i
== it
->nglyphs
- 1)
8434 /* If this is the destination position,
8435 return a position *before* it in this row,
8436 now that we know it fits in this row. */
8437 if (BUFFER_POS_REACHED_P ())
8439 if (it
->line_wrap
!= WORD_WRAP
8442 it
->hpos
= hpos_before_this_char
;
8443 it
->current_x
= x_before_this_char
;
8444 result
= MOVE_POS_MATCH_OR_ZV
;
8447 if (it
->line_wrap
== WORD_WRAP
8450 SAVE_IT (atpos_it
, *it
, atpos_data
);
8451 atpos_it
.current_x
= x_before_this_char
;
8452 atpos_it
.hpos
= hpos_before_this_char
;
8456 prev_method
= it
->method
;
8457 if (it
->method
== GET_FROM_BUFFER
)
8458 prev_pos
= IT_CHARPOS (*it
);
8459 set_iterator_to_next (it
, 1);
8460 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8461 SET_TEXT_POS (this_line_min_pos
,
8462 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8463 /* On graphical terminals, newlines may
8464 "overflow" into the fringe if
8465 overflow-newline-into-fringe is non-nil.
8466 On text terminals, and on graphical
8467 terminals with no right margin, newlines
8468 may overflow into the last glyph on the
8470 if (!FRAME_WINDOW_P (it
->f
)
8472 && it
->bidi_it
.paragraph_dir
== R2L
)
8473 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8474 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8475 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8477 if (!get_next_display_element (it
))
8479 result
= MOVE_POS_MATCH_OR_ZV
;
8482 if (BUFFER_POS_REACHED_P ())
8484 if (ITERATOR_AT_END_OF_LINE_P (it
))
8485 result
= MOVE_POS_MATCH_OR_ZV
;
8487 result
= MOVE_LINE_CONTINUED
;
8490 if (ITERATOR_AT_END_OF_LINE_P (it
))
8492 result
= MOVE_NEWLINE_OR_CR
;
8499 IT_RESET_X_ASCENT_DESCENT (it
);
8501 if (wrap_it
.sp
>= 0)
8503 RESTORE_IT (it
, &wrap_it
, wrap_data
);
8508 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
8510 result
= MOVE_LINE_CONTINUED
;
8514 if (BUFFER_POS_REACHED_P ())
8516 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
8517 goto buffer_pos_reached
;
8518 if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
8520 SAVE_IT (atpos_it
, *it
, atpos_data
);
8521 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
8525 if (new_x
> it
->first_visible_x
)
8527 /* Glyph is visible. Increment number of glyphs that
8528 would be displayed. */
8533 if (result
!= MOVE_UNDEFINED
)
8536 else if (BUFFER_POS_REACHED_P ())
8539 IT_RESET_X_ASCENT_DESCENT (it
);
8540 result
= MOVE_POS_MATCH_OR_ZV
;
8543 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
8545 /* Stop when TO_X specified and reached. This check is
8546 necessary here because of lines consisting of a line end,
8547 only. The line end will not produce any glyphs and we
8548 would never get MOVE_X_REACHED. */
8549 eassert (it
->nglyphs
== 0);
8550 result
= MOVE_X_REACHED
;
8554 /* Is this a line end? If yes, we're done. */
8555 if (ITERATOR_AT_END_OF_LINE_P (it
))
8557 /* If we are past TO_CHARPOS, but never saw any character
8558 positions smaller than TO_CHARPOS, return
8559 MOVE_POS_MATCH_OR_ZV, like the unidirectional display
8561 if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0)
8563 if (!saw_smaller_pos
&& IT_CHARPOS (*it
) > to_charpos
)
8565 if (IT_CHARPOS (ppos_it
) < ZV
)
8567 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8568 result
= MOVE_POS_MATCH_OR_ZV
;
8571 goto buffer_pos_reached
;
8573 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
>= 0
8574 && IT_CHARPOS (*it
) > to_charpos
)
8575 goto buffer_pos_reached
;
8577 result
= MOVE_NEWLINE_OR_CR
;
8580 result
= MOVE_NEWLINE_OR_CR
;
8584 prev_method
= it
->method
;
8585 if (it
->method
== GET_FROM_BUFFER
)
8586 prev_pos
= IT_CHARPOS (*it
);
8587 /* The current display element has been consumed. Advance
8589 set_iterator_to_next (it
, 1);
8590 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8591 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8592 if (IT_CHARPOS (*it
) < to_charpos
)
8593 saw_smaller_pos
= 1;
8595 && (op
& MOVE_TO_POS
)
8596 && IT_CHARPOS (*it
) >= to_charpos
8597 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
8598 SAVE_IT (ppos_it
, *it
, ppos_data
);
8600 /* Stop if lines are truncated and IT's current x-position is
8601 past the right edge of the window now. */
8602 if (it
->line_wrap
== TRUNCATE
8603 && it
->current_x
>= it
->last_visible_x
)
8605 if (!FRAME_WINDOW_P (it
->f
)
8606 || ((it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
8607 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
8608 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0
8609 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8613 if ((at_eob_p
= !get_next_display_element (it
))
8614 || BUFFER_POS_REACHED_P ()
8615 /* If we are past TO_CHARPOS, but never saw any
8616 character positions smaller than TO_CHARPOS,
8617 return MOVE_POS_MATCH_OR_ZV, like the
8618 unidirectional display did. */
8619 || (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8621 && IT_CHARPOS (*it
) > to_charpos
))
8624 && !at_eob_p
&& IT_CHARPOS (ppos_it
) < ZV
)
8625 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8626 result
= MOVE_POS_MATCH_OR_ZV
;
8629 if (ITERATOR_AT_END_OF_LINE_P (it
))
8631 result
= MOVE_NEWLINE_OR_CR
;
8635 else if (it
->bidi_p
&& (op
& MOVE_TO_POS
) != 0
8637 && IT_CHARPOS (*it
) > to_charpos
)
8639 if (IT_CHARPOS (ppos_it
) < ZV
)
8640 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8641 result
= MOVE_POS_MATCH_OR_ZV
;
8644 result
= MOVE_LINE_TRUNCATED
;
8647 #undef IT_RESET_X_ASCENT_DESCENT
8650 #undef BUFFER_POS_REACHED_P
8652 /* If we scanned beyond to_pos and didn't find a point to wrap at,
8653 restore the saved iterator. */
8654 if (atpos_it
.sp
>= 0)
8655 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8656 else if (atx_it
.sp
>= 0)
8657 RESTORE_IT (it
, &atx_it
, atx_data
);
8662 bidi_unshelve_cache (atpos_data
, 1);
8664 bidi_unshelve_cache (atx_data
, 1);
8666 bidi_unshelve_cache (wrap_data
, 1);
8668 bidi_unshelve_cache (ppos_data
, 1);
8670 /* Restore the iterator settings altered at the beginning of this
8672 it
->glyph_row
= saved_glyph_row
;
8676 /* For external use. */
8678 move_it_in_display_line (struct it
*it
,
8679 ptrdiff_t to_charpos
, int to_x
,
8680 enum move_operation_enum op
)
8682 if (it
->line_wrap
== WORD_WRAP
8683 && (op
& MOVE_TO_X
))
8686 void *save_data
= NULL
;
8689 SAVE_IT (save_it
, *it
, save_data
);
8690 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8691 /* When word-wrap is on, TO_X may lie past the end
8692 of a wrapped line. Then it->current is the
8693 character on the next line, so backtrack to the
8694 space before the wrap point. */
8695 if (skip
== MOVE_LINE_CONTINUED
)
8697 int prev_x
= max (it
->current_x
- 1, 0);
8698 RESTORE_IT (it
, &save_it
, save_data
);
8699 move_it_in_display_line_to
8700 (it
, -1, prev_x
, MOVE_TO_X
);
8703 bidi_unshelve_cache (save_data
, 1);
8706 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8710 /* Move IT forward until it satisfies one or more of the criteria in
8711 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
8713 OP is a bit-mask that specifies where to stop, and in particular,
8714 which of those four position arguments makes a difference. See the
8715 description of enum move_operation_enum.
8717 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
8718 screen line, this function will set IT to the next position that is
8719 displayed to the right of TO_CHARPOS on the screen. */
8722 move_it_to (struct it
*it
, ptrdiff_t to_charpos
, int to_x
, int to_y
, int to_vpos
, int op
)
8724 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
8725 int line_height
, line_start_x
= 0, reached
= 0;
8726 void *backup_data
= NULL
;
8730 if (op
& MOVE_TO_VPOS
)
8732 /* If no TO_CHARPOS and no TO_X specified, stop at the
8733 start of the line TO_VPOS. */
8734 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
8736 if (it
->vpos
== to_vpos
)
8742 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
8746 /* TO_VPOS >= 0 means stop at TO_X in the line at
8747 TO_VPOS, or at TO_POS, whichever comes first. */
8748 if (it
->vpos
== to_vpos
)
8754 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8756 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
8761 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
8763 /* We have reached TO_X but not in the line we want. */
8764 skip
= move_it_in_display_line_to (it
, to_charpos
,
8766 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8774 else if (op
& MOVE_TO_Y
)
8776 struct it it_backup
;
8778 if (it
->line_wrap
== WORD_WRAP
)
8779 SAVE_IT (it_backup
, *it
, backup_data
);
8781 /* TO_Y specified means stop at TO_X in the line containing
8782 TO_Y---or at TO_CHARPOS if this is reached first. The
8783 problem is that we can't really tell whether the line
8784 contains TO_Y before we have completely scanned it, and
8785 this may skip past TO_X. What we do is to first scan to
8788 If TO_X is not specified, use a TO_X of zero. The reason
8789 is to make the outcome of this function more predictable.
8790 If we didn't use TO_X == 0, we would stop at the end of
8791 the line which is probably not what a caller would expect
8793 skip
= move_it_in_display_line_to
8794 (it
, to_charpos
, ((op
& MOVE_TO_X
) ? to_x
: 0),
8795 (MOVE_TO_X
| (op
& MOVE_TO_POS
)));
8797 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
8798 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8800 else if (skip
== MOVE_X_REACHED
)
8802 /* If TO_X was reached, we want to know whether TO_Y is
8803 in the line. We know this is the case if the already
8804 scanned glyphs make the line tall enough. Otherwise,
8805 we must check by scanning the rest of the line. */
8806 line_height
= it
->max_ascent
+ it
->max_descent
;
8807 if (to_y
>= it
->current_y
8808 && to_y
< it
->current_y
+ line_height
)
8813 SAVE_IT (it_backup
, *it
, backup_data
);
8814 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
8815 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
8817 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
8818 line_height
= it
->max_ascent
+ it
->max_descent
;
8819 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8821 if (to_y
>= it
->current_y
8822 && to_y
< it
->current_y
+ line_height
)
8824 /* If TO_Y is in this line and TO_X was reached
8825 above, we scanned too far. We have to restore
8826 IT's settings to the ones before skipping. But
8827 keep the more accurate values of max_ascent and
8828 max_descent we've found while skipping the rest
8829 of the line, for the sake of callers, such as
8830 pos_visible_p, that need to know the line
8832 int max_ascent
= it
->max_ascent
;
8833 int max_descent
= it
->max_descent
;
8835 RESTORE_IT (it
, &it_backup
, backup_data
);
8836 it
->max_ascent
= max_ascent
;
8837 it
->max_descent
= max_descent
;
8843 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8849 /* Check whether TO_Y is in this line. */
8850 line_height
= it
->max_ascent
+ it
->max_descent
;
8851 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8853 if (to_y
>= it
->current_y
8854 && to_y
< it
->current_y
+ line_height
)
8856 /* When word-wrap is on, TO_X may lie past the end
8857 of a wrapped line. Then it->current is the
8858 character on the next line, so backtrack to the
8859 space before the wrap point. */
8860 if (skip
== MOVE_LINE_CONTINUED
8861 && it
->line_wrap
== WORD_WRAP
)
8863 int prev_x
= max (it
->current_x
- 1, 0);
8864 RESTORE_IT (it
, &it_backup
, backup_data
);
8865 skip
= move_it_in_display_line_to
8866 (it
, -1, prev_x
, MOVE_TO_X
);
8875 else if (BUFFERP (it
->object
)
8876 && (it
->method
== GET_FROM_BUFFER
8877 || it
->method
== GET_FROM_STRETCH
)
8878 && IT_CHARPOS (*it
) >= to_charpos
8879 /* Under bidi iteration, a call to set_iterator_to_next
8880 can scan far beyond to_charpos if the initial
8881 portion of the next line needs to be reordered. In
8882 that case, give move_it_in_display_line_to another
8885 && it
->bidi_it
.scan_dir
== -1))
8886 skip
= MOVE_POS_MATCH_OR_ZV
;
8888 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
8892 case MOVE_POS_MATCH_OR_ZV
:
8896 case MOVE_NEWLINE_OR_CR
:
8897 set_iterator_to_next (it
, 1);
8898 it
->continuation_lines_width
= 0;
8901 case MOVE_LINE_TRUNCATED
:
8902 it
->continuation_lines_width
= 0;
8903 reseat_at_next_visible_line_start (it
, 0);
8904 if ((op
& MOVE_TO_POS
) != 0
8905 && IT_CHARPOS (*it
) > to_charpos
)
8912 case MOVE_LINE_CONTINUED
:
8913 /* For continued lines ending in a tab, some of the glyphs
8914 associated with the tab are displayed on the current
8915 line. Since it->current_x does not include these glyphs,
8916 we use it->last_visible_x instead. */
8919 it
->continuation_lines_width
+= it
->last_visible_x
;
8920 /* When moving by vpos, ensure that the iterator really
8921 advances to the next line (bug#847, bug#969). Fixme:
8922 do we need to do this in other circumstances? */
8923 if (it
->current_x
!= it
->last_visible_x
8924 && (op
& MOVE_TO_VPOS
)
8925 && !(op
& (MOVE_TO_X
| MOVE_TO_POS
)))
8927 line_start_x
= it
->current_x
+ it
->pixel_width
8928 - it
->last_visible_x
;
8929 set_iterator_to_next (it
, 0);
8933 it
->continuation_lines_width
+= it
->current_x
;
8940 /* Reset/increment for the next run. */
8941 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
8942 it
->current_x
= line_start_x
;
8945 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8947 last_height
= it
->max_ascent
+ it
->max_descent
;
8948 last_max_ascent
= it
->max_ascent
;
8949 it
->max_ascent
= it
->max_descent
= 0;
8954 /* On text terminals, we may stop at the end of a line in the middle
8955 of a multi-character glyph. If the glyph itself is continued,
8956 i.e. it is actually displayed on the next line, don't treat this
8957 stopping point as valid; move to the next line instead (unless
8958 that brings us offscreen). */
8959 if (!FRAME_WINDOW_P (it
->f
)
8961 && IT_CHARPOS (*it
) == to_charpos
8962 && it
->what
== IT_CHARACTER
8964 && it
->line_wrap
== WINDOW_WRAP
8965 && it
->current_x
== it
->last_visible_x
- 1
8968 && it
->vpos
< XFASTINT (it
->w
->window_end_vpos
))
8970 it
->continuation_lines_width
+= it
->current_x
;
8971 it
->current_x
= it
->hpos
= it
->max_ascent
= it
->max_descent
= 0;
8972 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8974 last_height
= it
->max_ascent
+ it
->max_descent
;
8975 last_max_ascent
= it
->max_ascent
;
8979 bidi_unshelve_cache (backup_data
, 1);
8981 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
8985 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
8987 If DY > 0, move IT backward at least that many pixels. DY = 0
8988 means move IT backward to the preceding line start or BEGV. This
8989 function may move over more than DY pixels if IT->current_y - DY
8990 ends up in the middle of a line; in this case IT->current_y will be
8991 set to the top of the line moved to. */
8994 move_it_vertically_backward (struct it
*it
, int dy
)
8998 void *it2data
= NULL
, *it3data
= NULL
;
8999 ptrdiff_t start_pos
;
9004 start_pos
= IT_CHARPOS (*it
);
9006 /* Estimate how many newlines we must move back. */
9007 nlines
= max (1, dy
/ FRAME_LINE_HEIGHT (it
->f
));
9009 /* Set the iterator's position that many lines back. */
9010 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
9011 back_to_previous_visible_line_start (it
);
9013 /* Reseat the iterator here. When moving backward, we don't want
9014 reseat to skip forward over invisible text, set up the iterator
9015 to deliver from overlay strings at the new position etc. So,
9016 use reseat_1 here. */
9017 reseat_1 (it
, it
->current
.pos
, 1);
9019 /* We are now surely at a line start. */
9020 it
->current_x
= it
->hpos
= 0; /* FIXME: this is incorrect when bidi
9021 reordering is in effect. */
9022 it
->continuation_lines_width
= 0;
9024 /* Move forward and see what y-distance we moved. First move to the
9025 start of the next line so that we get its height. We need this
9026 height to be able to tell whether we reached the specified
9028 SAVE_IT (it2
, *it
, it2data
);
9029 it2
.max_ascent
= it2
.max_descent
= 0;
9032 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
9033 MOVE_TO_POS
| MOVE_TO_VPOS
);
9035 while (!(IT_POS_VALID_AFTER_MOVE_P (&it2
)
9036 /* If we are in a display string which starts at START_POS,
9037 and that display string includes a newline, and we are
9038 right after that newline (i.e. at the beginning of a
9039 display line), exit the loop, because otherwise we will
9040 infloop, since move_it_to will see that it is already at
9041 START_POS and will not move. */
9042 || (it2
.method
== GET_FROM_STRING
9043 && IT_CHARPOS (it2
) == start_pos
9044 && SREF (it2
.string
, IT_STRING_BYTEPOS (it2
) - 1) == '\n')));
9045 eassert (IT_CHARPOS (*it
) >= BEGV
);
9046 SAVE_IT (it3
, it2
, it3data
);
9048 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
9049 eassert (IT_CHARPOS (*it
) >= BEGV
);
9050 /* H is the actual vertical distance from the position in *IT
9051 and the starting position. */
9052 h
= it2
.current_y
- it
->current_y
;
9053 /* NLINES is the distance in number of lines. */
9054 nlines
= it2
.vpos
- it
->vpos
;
9056 /* Correct IT's y and vpos position
9057 so that they are relative to the starting point. */
9063 /* DY == 0 means move to the start of the screen line. The
9064 value of nlines is > 0 if continuation lines were involved,
9065 or if the original IT position was at start of a line. */
9066 RESTORE_IT (it
, it
, it2data
);
9068 move_it_by_lines (it
, nlines
);
9069 /* The above code moves us to some position NLINES down,
9070 usually to its first glyph (leftmost in an L2R line), but
9071 that's not necessarily the start of the line, under bidi
9072 reordering. We want to get to the character position
9073 that is immediately after the newline of the previous
9076 && !it
->continuation_lines_width
9077 && !STRINGP (it
->string
)
9078 && IT_CHARPOS (*it
) > BEGV
9079 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9082 find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
9084 move_it_to (it
, nl_pos
, -1, -1, -1, MOVE_TO_POS
);
9086 bidi_unshelve_cache (it3data
, 1);
9090 /* The y-position we try to reach, relative to *IT.
9091 Note that H has been subtracted in front of the if-statement. */
9092 int target_y
= it
->current_y
+ h
- dy
;
9093 int y0
= it3
.current_y
;
9097 RESTORE_IT (&it3
, &it3
, it3data
);
9098 y1
= line_bottom_y (&it3
);
9099 line_height
= y1
- y0
;
9100 RESTORE_IT (it
, it
, it2data
);
9101 /* If we did not reach target_y, try to move further backward if
9102 we can. If we moved too far backward, try to move forward. */
9103 if (target_y
< it
->current_y
9104 /* This is heuristic. In a window that's 3 lines high, with
9105 a line height of 13 pixels each, recentering with point
9106 on the bottom line will try to move -39/2 = 19 pixels
9107 backward. Try to avoid moving into the first line. */
9108 && (it
->current_y
- target_y
9109 > min (window_box_height (it
->w
), line_height
* 2 / 3))
9110 && IT_CHARPOS (*it
) > BEGV
)
9112 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
9113 target_y
- it
->current_y
));
9114 dy
= it
->current_y
- target_y
;
9115 goto move_further_back
;
9117 else if (target_y
>= it
->current_y
+ line_height
9118 && IT_CHARPOS (*it
) < ZV
)
9120 /* Should move forward by at least one line, maybe more.
9122 Note: Calling move_it_by_lines can be expensive on
9123 terminal frames, where compute_motion is used (via
9124 vmotion) to do the job, when there are very long lines
9125 and truncate-lines is nil. That's the reason for
9126 treating terminal frames specially here. */
9128 if (!FRAME_WINDOW_P (it
->f
))
9129 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
9134 move_it_by_lines (it
, 1);
9136 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
9143 /* Move IT by a specified amount of pixel lines DY. DY negative means
9144 move backwards. DY = 0 means move to start of screen line. At the
9145 end, IT will be on the start of a screen line. */
9148 move_it_vertically (struct it
*it
, int dy
)
9151 move_it_vertically_backward (it
, -dy
);
9154 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
9155 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
9156 MOVE_TO_POS
| MOVE_TO_Y
);
9157 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
9159 /* If buffer ends in ZV without a newline, move to the start of
9160 the line to satisfy the post-condition. */
9161 if (IT_CHARPOS (*it
) == ZV
9163 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
9164 move_it_by_lines (it
, 0);
9169 /* Move iterator IT past the end of the text line it is in. */
9172 move_it_past_eol (struct it
*it
)
9174 enum move_it_result rc
;
9176 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
9177 if (rc
== MOVE_NEWLINE_OR_CR
)
9178 set_iterator_to_next (it
, 0);
9182 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
9183 negative means move up. DVPOS == 0 means move to the start of the
9186 Optimization idea: If we would know that IT->f doesn't use
9187 a face with proportional font, we could be faster for
9188 truncate-lines nil. */
9191 move_it_by_lines (struct it
*it
, ptrdiff_t dvpos
)
9194 /* The commented-out optimization uses vmotion on terminals. This
9195 gives bad results, because elements like it->what, on which
9196 callers such as pos_visible_p rely, aren't updated. */
9197 /* struct position pos;
9198 if (!FRAME_WINDOW_P (it->f))
9200 struct text_pos textpos;
9202 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
9203 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
9204 reseat (it, textpos, 1);
9205 it->vpos += pos.vpos;
9206 it->current_y += pos.vpos;
9212 /* DVPOS == 0 means move to the start of the screen line. */
9213 move_it_vertically_backward (it
, 0);
9214 /* Let next call to line_bottom_y calculate real line height */
9219 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
9220 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
9222 /* Only move to the next buffer position if we ended up in a
9223 string from display property, not in an overlay string
9224 (before-string or after-string). That is because the
9225 latter don't conceal the underlying buffer position, so
9226 we can ask to move the iterator to the exact position we
9227 are interested in. Note that, even if we are already at
9228 IT_CHARPOS (*it), the call below is not a no-op, as it
9229 will detect that we are at the end of the string, pop the
9230 iterator, and compute it->current_x and it->hpos
9232 move_it_to (it
, IT_CHARPOS (*it
) + it
->string_from_display_prop_p
,
9233 -1, -1, -1, MOVE_TO_POS
);
9239 void *it2data
= NULL
;
9240 ptrdiff_t start_charpos
, i
;
9242 /* Start at the beginning of the screen line containing IT's
9243 position. This may actually move vertically backwards,
9244 in case of overlays, so adjust dvpos accordingly. */
9246 move_it_vertically_backward (it
, 0);
9249 /* Go back -DVPOS visible lines and reseat the iterator there. */
9250 start_charpos
= IT_CHARPOS (*it
);
9251 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > BEGV
; --i
)
9252 back_to_previous_visible_line_start (it
);
9253 reseat (it
, it
->current
.pos
, 1);
9255 /* Move further back if we end up in a string or an image. */
9256 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
9258 /* First try to move to start of display line. */
9260 move_it_vertically_backward (it
, 0);
9262 if (IT_POS_VALID_AFTER_MOVE_P (it
))
9264 /* If start of line is still in string or image,
9265 move further back. */
9266 back_to_previous_visible_line_start (it
);
9267 reseat (it
, it
->current
.pos
, 1);
9271 it
->current_x
= it
->hpos
= 0;
9273 /* Above call may have moved too far if continuation lines
9274 are involved. Scan forward and see if it did. */
9275 SAVE_IT (it2
, *it
, it2data
);
9276 it2
.vpos
= it2
.current_y
= 0;
9277 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
9278 it
->vpos
-= it2
.vpos
;
9279 it
->current_y
-= it2
.current_y
;
9280 it
->current_x
= it
->hpos
= 0;
9282 /* If we moved too far back, move IT some lines forward. */
9283 if (it2
.vpos
> -dvpos
)
9285 int delta
= it2
.vpos
+ dvpos
;
9287 RESTORE_IT (&it2
, &it2
, it2data
);
9288 SAVE_IT (it2
, *it
, it2data
);
9289 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
9290 /* Move back again if we got too far ahead. */
9291 if (IT_CHARPOS (*it
) >= start_charpos
)
9292 RESTORE_IT (it
, &it2
, it2data
);
9294 bidi_unshelve_cache (it2data
, 1);
9297 RESTORE_IT (it
, it
, it2data
);
9301 /* Return 1 if IT points into the middle of a display vector. */
9304 in_display_vector_p (struct it
*it
)
9306 return (it
->method
== GET_FROM_DISPLAY_VECTOR
9307 && it
->current
.dpvec_index
> 0
9308 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
9312 /***********************************************************************
9314 ***********************************************************************/
9317 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
9321 add_to_log (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
9323 Lisp_Object args
[3];
9324 Lisp_Object msg
, fmt
;
9327 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9331 GCPRO4 (fmt
, msg
, arg1
, arg2
);
9333 args
[0] = fmt
= build_string (format
);
9336 msg
= Fformat (3, args
);
9338 len
= SBYTES (msg
) + 1;
9339 buffer
= SAFE_ALLOCA (len
);
9340 memcpy (buffer
, SDATA (msg
), len
);
9342 message_dolog (buffer
, len
- 1, 1, 0);
9349 /* Output a newline in the *Messages* buffer if "needs" one. */
9352 message_log_maybe_newline (void)
9354 if (message_log_need_newline
)
9355 message_dolog ("", 0, 1, 0);
9359 /* Add a string M of length NBYTES to the message log, optionally
9360 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
9361 nonzero, means interpret the contents of M as multibyte. This
9362 function calls low-level routines in order to bypass text property
9363 hooks, etc. which might not be safe to run.
9365 This may GC (insert may run before/after change hooks),
9366 so the buffer M must NOT point to a Lisp string. */
9369 message_dolog (const char *m
, ptrdiff_t nbytes
, int nlflag
, int multibyte
)
9371 const unsigned char *msg
= (const unsigned char *) m
;
9373 if (!NILP (Vmemory_full
))
9376 if (!NILP (Vmessage_log_max
))
9378 struct buffer
*oldbuf
;
9379 Lisp_Object oldpoint
, oldbegv
, oldzv
;
9380 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
9381 ptrdiff_t point_at_end
= 0;
9382 ptrdiff_t zv_at_end
= 0;
9383 Lisp_Object old_deactivate_mark
, tem
;
9384 struct gcpro gcpro1
;
9386 old_deactivate_mark
= Vdeactivate_mark
;
9387 oldbuf
= current_buffer
;
9388 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
9389 bset_undo_list (current_buffer
, Qt
);
9391 oldpoint
= message_dolog_marker1
;
9392 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
9393 oldbegv
= message_dolog_marker2
;
9394 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
9395 oldzv
= message_dolog_marker3
;
9396 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
9397 GCPRO1 (old_deactivate_mark
);
9405 BEGV_BYTE
= BEG_BYTE
;
9408 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
9410 /* Insert the string--maybe converting multibyte to single byte
9411 or vice versa, so that all the text fits the buffer. */
9413 && NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9419 /* Convert a multibyte string to single-byte
9420 for the *Message* buffer. */
9421 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
9423 c
= string_char_and_length (msg
+ i
, &char_bytes
);
9424 work
[0] = (ASCII_CHAR_P (c
)
9426 : multibyte_char_to_unibyte (c
));
9427 insert_1_both (work
, 1, 1, 1, 0, 0);
9430 else if (! multibyte
9431 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9435 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
9436 /* Convert a single-byte string to multibyte
9437 for the *Message* buffer. */
9438 for (i
= 0; i
< nbytes
; i
++)
9441 MAKE_CHAR_MULTIBYTE (c
);
9442 char_bytes
= CHAR_STRING (c
, str
);
9443 insert_1_both ((char *) str
, 1, char_bytes
, 1, 0, 0);
9447 insert_1 (m
, nbytes
, 1, 0, 0);
9451 ptrdiff_t this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
;
9453 insert_1 ("\n", 1, 1, 0, 0);
9455 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9457 this_bol_byte
= PT_BYTE
;
9459 /* See if this line duplicates the previous one.
9460 If so, combine duplicates. */
9463 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
9465 prev_bol_byte
= PT_BYTE
;
9467 dups
= message_log_check_duplicate (prev_bol_byte
,
9471 del_range_both (prev_bol
, prev_bol_byte
,
9472 this_bol
, this_bol_byte
, 0);
9475 char dupstr
[sizeof " [ times]"
9476 + INT_STRLEN_BOUND (printmax_t
)];
9478 /* If you change this format, don't forget to also
9479 change message_log_check_duplicate. */
9480 int duplen
= sprintf (dupstr
, " [%"pMd
" times]", dups
);
9481 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
9482 insert_1 (dupstr
, duplen
, 1, 0, 1);
9487 /* If we have more than the desired maximum number of lines
9488 in the *Messages* buffer now, delete the oldest ones.
9489 This is safe because we don't have undo in this buffer. */
9491 if (NATNUMP (Vmessage_log_max
))
9493 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
9494 -XFASTINT (Vmessage_log_max
) - 1, 0);
9495 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
9498 BEGV
= XMARKER (oldbegv
)->charpos
;
9499 BEGV_BYTE
= marker_byte_position (oldbegv
);
9508 ZV
= XMARKER (oldzv
)->charpos
;
9509 ZV_BYTE
= marker_byte_position (oldzv
);
9513 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
9515 /* We can't do Fgoto_char (oldpoint) because it will run some
9517 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
9518 XMARKER (oldpoint
)->bytepos
);
9521 unchain_marker (XMARKER (oldpoint
));
9522 unchain_marker (XMARKER (oldbegv
));
9523 unchain_marker (XMARKER (oldzv
));
9525 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
9526 set_buffer_internal (oldbuf
);
9528 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
9529 message_log_need_newline
= !nlflag
;
9530 Vdeactivate_mark
= old_deactivate_mark
;
9535 /* We are at the end of the buffer after just having inserted a newline.
9536 (Note: We depend on the fact we won't be crossing the gap.)
9537 Check to see if the most recent message looks a lot like the previous one.
9538 Return 0 if different, 1 if the new one should just replace it, or a
9539 value N > 1 if we should also append " [N times]". */
9542 message_log_check_duplicate (ptrdiff_t prev_bol_byte
, ptrdiff_t this_bol_byte
)
9545 ptrdiff_t len
= Z_BYTE
- 1 - this_bol_byte
;
9547 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
9548 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
9550 for (i
= 0; i
< len
; i
++)
9552 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
9560 if (*p1
++ == ' ' && *p1
++ == '[')
9563 intmax_t n
= strtoimax ((char *) p1
, &pend
, 10);
9564 if (0 < n
&& n
< INTMAX_MAX
&& strncmp (pend
, " times]\n", 8) == 0)
9571 /* Display an echo area message M with a specified length of NBYTES
9572 bytes. The string may include null characters. If M is 0, clear
9573 out any existing message, and let the mini-buffer text show
9576 This may GC, so the buffer M must NOT point to a Lisp string. */
9579 message2 (const char *m
, ptrdiff_t nbytes
, int multibyte
)
9581 /* First flush out any partial line written with print. */
9582 message_log_maybe_newline ();
9584 message_dolog (m
, nbytes
, 1, multibyte
);
9585 message2_nolog (m
, nbytes
, multibyte
);
9589 /* The non-logging counterpart of message2. */
9592 message2_nolog (const char *m
, ptrdiff_t nbytes
, int multibyte
)
9594 struct frame
*sf
= SELECTED_FRAME ();
9595 message_enable_multibyte
= multibyte
;
9597 if (FRAME_INITIAL_P (sf
))
9599 if (noninteractive_need_newline
)
9600 putc ('\n', stderr
);
9601 noninteractive_need_newline
= 0;
9603 fwrite (m
, nbytes
, 1, stderr
);
9604 if (cursor_in_echo_area
== 0)
9605 fprintf (stderr
, "\n");
9608 /* A null message buffer means that the frame hasn't really been
9609 initialized yet. Error messages get reported properly by
9610 cmd_error, so this must be just an informative message; toss it. */
9611 else if (INTERACTIVE
9612 && sf
->glyphs_initialized_p
9613 && FRAME_MESSAGE_BUF (sf
))
9615 Lisp_Object mini_window
;
9618 /* Get the frame containing the mini-buffer
9619 that the selected frame is using. */
9620 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9621 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9623 FRAME_SAMPLE_VISIBILITY (f
);
9624 if (FRAME_VISIBLE_P (sf
)
9625 && ! FRAME_VISIBLE_P (f
))
9626 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
9630 set_message (m
, Qnil
, nbytes
, multibyte
);
9631 if (minibuffer_auto_raise
)
9632 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
9635 clear_message (1, 1);
9637 do_pending_window_change (0);
9638 echo_area_display (1);
9639 do_pending_window_change (0);
9640 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
9641 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9646 /* Display an echo area message M with a specified length of NBYTES
9647 bytes. The string may include null characters. If M is not a
9648 string, clear out any existing message, and let the mini-buffer
9651 This function cancels echoing. */
9654 message3 (Lisp_Object m
, ptrdiff_t nbytes
, int multibyte
)
9656 struct gcpro gcpro1
;
9659 clear_message (1,1);
9662 /* First flush out any partial line written with print. */
9663 message_log_maybe_newline ();
9667 char *buffer
= SAFE_ALLOCA (nbytes
);
9668 memcpy (buffer
, SDATA (m
), nbytes
);
9669 message_dolog (buffer
, nbytes
, 1, multibyte
);
9672 message3_nolog (m
, nbytes
, multibyte
);
9678 /* The non-logging version of message3.
9679 This does not cancel echoing, because it is used for echoing.
9680 Perhaps we need to make a separate function for echoing
9681 and make this cancel echoing. */
9684 message3_nolog (Lisp_Object m
, ptrdiff_t nbytes
, int multibyte
)
9686 struct frame
*sf
= SELECTED_FRAME ();
9687 message_enable_multibyte
= multibyte
;
9689 if (FRAME_INITIAL_P (sf
))
9691 if (noninteractive_need_newline
)
9692 putc ('\n', stderr
);
9693 noninteractive_need_newline
= 0;
9695 fwrite (SDATA (m
), nbytes
, 1, stderr
);
9696 if (cursor_in_echo_area
== 0)
9697 fprintf (stderr
, "\n");
9700 /* A null message buffer means that the frame hasn't really been
9701 initialized yet. Error messages get reported properly by
9702 cmd_error, so this must be just an informative message; toss it. */
9703 else if (INTERACTIVE
9704 && sf
->glyphs_initialized_p
9705 && FRAME_MESSAGE_BUF (sf
))
9707 Lisp_Object mini_window
;
9711 /* Get the frame containing the mini-buffer
9712 that the selected frame is using. */
9713 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9714 frame
= XWINDOW (mini_window
)->frame
;
9717 FRAME_SAMPLE_VISIBILITY (f
);
9718 if (FRAME_VISIBLE_P (sf
)
9719 && !FRAME_VISIBLE_P (f
))
9720 Fmake_frame_visible (frame
);
9722 if (STRINGP (m
) && SCHARS (m
) > 0)
9724 set_message (NULL
, m
, nbytes
, multibyte
);
9725 if (minibuffer_auto_raise
)
9726 Fraise_frame (frame
);
9727 /* Assume we are not echoing.
9728 (If we are, echo_now will override this.) */
9729 echo_message_buffer
= Qnil
;
9732 clear_message (1, 1);
9734 do_pending_window_change (0);
9735 echo_area_display (1);
9736 do_pending_window_change (0);
9737 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
9738 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9743 /* Display a null-terminated echo area message M. If M is 0, clear
9744 out any existing message, and let the mini-buffer text show through.
9746 The buffer M must continue to exist until after the echo area gets
9747 cleared or some other message gets displayed there. Do not pass
9748 text that is stored in a Lisp string. Do not pass text in a buffer
9749 that was alloca'd. */
9752 message1 (const char *m
)
9754 message2 (m
, (m
? strlen (m
) : 0), 0);
9758 /* The non-logging counterpart of message1. */
9761 message1_nolog (const char *m
)
9763 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
9766 /* Display a message M which contains a single %s
9767 which gets replaced with STRING. */
9770 message_with_string (const char *m
, Lisp_Object string
, int log
)
9772 CHECK_STRING (string
);
9778 if (noninteractive_need_newline
)
9779 putc ('\n', stderr
);
9780 noninteractive_need_newline
= 0;
9781 fprintf (stderr
, m
, SDATA (string
));
9782 if (!cursor_in_echo_area
)
9783 fprintf (stderr
, "\n");
9787 else if (INTERACTIVE
)
9789 /* The frame whose minibuffer we're going to display the message on.
9790 It may be larger than the selected frame, so we need
9791 to use its buffer, not the selected frame's buffer. */
9792 Lisp_Object mini_window
;
9793 struct frame
*f
, *sf
= SELECTED_FRAME ();
9795 /* Get the frame containing the minibuffer
9796 that the selected frame is using. */
9797 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9798 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9800 /* A null message buffer means that the frame hasn't really been
9801 initialized yet. Error messages get reported properly by
9802 cmd_error, so this must be just an informative message; toss it. */
9803 if (FRAME_MESSAGE_BUF (f
))
9805 Lisp_Object args
[2], msg
;
9806 struct gcpro gcpro1
, gcpro2
;
9808 args
[0] = build_string (m
);
9809 args
[1] = msg
= string
;
9810 GCPRO2 (args
[0], msg
);
9813 msg
= Fformat (2, args
);
9816 message3 (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9818 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9822 /* Print should start at the beginning of the message
9823 buffer next time. */
9824 message_buf_print
= 0;
9830 /* Dump an informative message to the minibuf. If M is 0, clear out
9831 any existing message, and let the mini-buffer text show through. */
9834 vmessage (const char *m
, va_list ap
)
9840 if (noninteractive_need_newline
)
9841 putc ('\n', stderr
);
9842 noninteractive_need_newline
= 0;
9843 vfprintf (stderr
, m
, ap
);
9844 if (cursor_in_echo_area
== 0)
9845 fprintf (stderr
, "\n");
9849 else if (INTERACTIVE
)
9851 /* The frame whose mini-buffer we're going to display the message
9852 on. It may be larger than the selected frame, so we need to
9853 use its buffer, not the selected frame's buffer. */
9854 Lisp_Object mini_window
;
9855 struct frame
*f
, *sf
= SELECTED_FRAME ();
9857 /* Get the frame containing the mini-buffer
9858 that the selected frame is using. */
9859 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9860 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9862 /* A null message buffer means that the frame hasn't really been
9863 initialized yet. Error messages get reported properly by
9864 cmd_error, so this must be just an informative message; toss
9866 if (FRAME_MESSAGE_BUF (f
))
9872 len
= doprnt (FRAME_MESSAGE_BUF (f
),
9873 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, ap
);
9875 message2 (FRAME_MESSAGE_BUF (f
), len
, 1);
9880 /* Print should start at the beginning of the message
9881 buffer next time. */
9882 message_buf_print
= 0;
9888 message (const char *m
, ...)
9898 /* The non-logging version of message. */
9901 message_nolog (const char *m
, ...)
9903 Lisp_Object old_log_max
;
9906 old_log_max
= Vmessage_log_max
;
9907 Vmessage_log_max
= Qnil
;
9909 Vmessage_log_max
= old_log_max
;
9915 /* Display the current message in the current mini-buffer. This is
9916 only called from error handlers in process.c, and is not time
9920 update_echo_area (void)
9922 if (!NILP (echo_area_buffer
[0]))
9925 string
= Fcurrent_message ();
9926 message3 (string
, SBYTES (string
),
9927 !NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
9932 /* Make sure echo area buffers in `echo_buffers' are live.
9933 If they aren't, make new ones. */
9936 ensure_echo_area_buffers (void)
9940 for (i
= 0; i
< 2; ++i
)
9941 if (!BUFFERP (echo_buffer
[i
])
9942 || !BUFFER_LIVE_P (XBUFFER (echo_buffer
[i
])))
9945 Lisp_Object old_buffer
;
9948 old_buffer
= echo_buffer
[i
];
9949 echo_buffer
[i
] = Fget_buffer_create
9950 (make_formatted_string (name
, " *Echo Area %d*", i
));
9951 bset_truncate_lines (XBUFFER (echo_buffer
[i
]), Qnil
);
9952 /* to force word wrap in echo area -
9953 it was decided to postpone this*/
9954 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
9956 for (j
= 0; j
< 2; ++j
)
9957 if (EQ (old_buffer
, echo_area_buffer
[j
]))
9958 echo_area_buffer
[j
] = echo_buffer
[i
];
9963 /* Call FN with args A1..A4 with either the current or last displayed
9964 echo_area_buffer as current buffer.
9966 WHICH zero means use the current message buffer
9967 echo_area_buffer[0]. If that is nil, choose a suitable buffer
9968 from echo_buffer[] and clear it.
9970 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
9971 suitable buffer from echo_buffer[] and clear it.
9973 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
9974 that the current message becomes the last displayed one, make
9975 choose a suitable buffer for echo_area_buffer[0], and clear it.
9977 Value is what FN returns. */
9980 with_echo_area_buffer (struct window
*w
, int which
,
9981 int (*fn
) (ptrdiff_t, Lisp_Object
, ptrdiff_t, ptrdiff_t),
9982 ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
9985 int this_one
, the_other
, clear_buffer_p
, rc
;
9986 ptrdiff_t count
= SPECPDL_INDEX ();
9988 /* If buffers aren't live, make new ones. */
9989 ensure_echo_area_buffers ();
9994 this_one
= 0, the_other
= 1;
9996 this_one
= 1, the_other
= 0;
9999 this_one
= 0, the_other
= 1;
10000 clear_buffer_p
= 1;
10002 /* We need a fresh one in case the current echo buffer equals
10003 the one containing the last displayed echo area message. */
10004 if (!NILP (echo_area_buffer
[this_one
])
10005 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
10006 echo_area_buffer
[this_one
] = Qnil
;
10009 /* Choose a suitable buffer from echo_buffer[] is we don't
10011 if (NILP (echo_area_buffer
[this_one
]))
10013 echo_area_buffer
[this_one
]
10014 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
10015 ? echo_buffer
[the_other
]
10016 : echo_buffer
[this_one
]);
10017 clear_buffer_p
= 1;
10020 buffer
= echo_area_buffer
[this_one
];
10022 /* Don't get confused by reusing the buffer used for echoing
10023 for a different purpose. */
10024 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
10027 record_unwind_protect (unwind_with_echo_area_buffer
,
10028 with_echo_area_buffer_unwind_data (w
));
10030 /* Make the echo area buffer current. Note that for display
10031 purposes, it is not necessary that the displayed window's buffer
10032 == current_buffer, except for text property lookup. So, let's
10033 only set that buffer temporarily here without doing a full
10034 Fset_window_buffer. We must also change w->pointm, though,
10035 because otherwise an assertions in unshow_buffer fails, and Emacs
10037 set_buffer_internal_1 (XBUFFER (buffer
));
10040 wset_buffer (w
, buffer
);
10041 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
10044 bset_undo_list (current_buffer
, Qt
);
10045 bset_read_only (current_buffer
, Qnil
);
10046 specbind (Qinhibit_read_only
, Qt
);
10047 specbind (Qinhibit_modification_hooks
, Qt
);
10049 if (clear_buffer_p
&& Z
> BEG
)
10050 del_range (BEG
, Z
);
10052 eassert (BEGV
>= BEG
);
10053 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10055 rc
= fn (a1
, a2
, a3
, a4
);
10057 eassert (BEGV
>= BEG
);
10058 eassert (ZV
<= Z
&& ZV
>= BEGV
);
10060 unbind_to (count
, Qnil
);
10065 /* Save state that should be preserved around the call to the function
10066 FN called in with_echo_area_buffer. */
10069 with_echo_area_buffer_unwind_data (struct window
*w
)
10072 Lisp_Object vector
, tmp
;
10074 /* Reduce consing by keeping one vector in
10075 Vwith_echo_area_save_vector. */
10076 vector
= Vwith_echo_area_save_vector
;
10077 Vwith_echo_area_save_vector
= Qnil
;
10080 vector
= Fmake_vector (make_number (7), Qnil
);
10082 XSETBUFFER (tmp
, current_buffer
); ASET (vector
, i
, tmp
); ++i
;
10083 ASET (vector
, i
, Vdeactivate_mark
); ++i
;
10084 ASET (vector
, i
, make_number (windows_or_buffers_changed
)); ++i
;
10088 XSETWINDOW (tmp
, w
); ASET (vector
, i
, tmp
); ++i
;
10089 ASET (vector
, i
, w
->buffer
); ++i
;
10090 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->charpos
)); ++i
;
10091 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->bytepos
)); ++i
;
10096 for (; i
< end
; ++i
)
10097 ASET (vector
, i
, Qnil
);
10100 eassert (i
== ASIZE (vector
));
10105 /* Restore global state from VECTOR which was created by
10106 with_echo_area_buffer_unwind_data. */
10109 unwind_with_echo_area_buffer (Lisp_Object vector
)
10111 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
10112 Vdeactivate_mark
= AREF (vector
, 1);
10113 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
10115 if (WINDOWP (AREF (vector
, 3)))
10118 Lisp_Object buffer
, charpos
, bytepos
;
10120 w
= XWINDOW (AREF (vector
, 3));
10121 buffer
= AREF (vector
, 4);
10122 charpos
= AREF (vector
, 5);
10123 bytepos
= AREF (vector
, 6);
10125 wset_buffer (w
, buffer
);
10126 set_marker_both (w
->pointm
, buffer
,
10127 XFASTINT (charpos
), XFASTINT (bytepos
));
10130 Vwith_echo_area_save_vector
= vector
;
10135 /* Set up the echo area for use by print functions. MULTIBYTE_P
10136 non-zero means we will print multibyte. */
10139 setup_echo_area_for_printing (int multibyte_p
)
10141 /* If we can't find an echo area any more, exit. */
10142 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
10143 Fkill_emacs (Qnil
);
10145 ensure_echo_area_buffers ();
10147 if (!message_buf_print
)
10149 /* A message has been output since the last time we printed.
10150 Choose a fresh echo area buffer. */
10151 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10152 echo_area_buffer
[0] = echo_buffer
[1];
10154 echo_area_buffer
[0] = echo_buffer
[0];
10156 /* Switch to that buffer and clear it. */
10157 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10158 bset_truncate_lines (current_buffer
, Qnil
);
10162 ptrdiff_t count
= SPECPDL_INDEX ();
10163 specbind (Qinhibit_read_only
, Qt
);
10164 /* Note that undo recording is always disabled. */
10165 del_range (BEG
, Z
);
10166 unbind_to (count
, Qnil
);
10168 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10170 /* Set up the buffer for the multibyteness we need. */
10172 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10173 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
10175 /* Raise the frame containing the echo area. */
10176 if (minibuffer_auto_raise
)
10178 struct frame
*sf
= SELECTED_FRAME ();
10179 Lisp_Object mini_window
;
10180 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10181 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
10184 message_log_maybe_newline ();
10185 message_buf_print
= 1;
10189 if (NILP (echo_area_buffer
[0]))
10191 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
10192 echo_area_buffer
[0] = echo_buffer
[1];
10194 echo_area_buffer
[0] = echo_buffer
[0];
10197 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
10199 /* Someone switched buffers between print requests. */
10200 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
10201 bset_truncate_lines (current_buffer
, Qnil
);
10207 /* Display an echo area message in window W. Value is non-zero if W's
10208 height is changed. If display_last_displayed_message_p is
10209 non-zero, display the message that was last displayed, otherwise
10210 display the current message. */
10213 display_echo_area (struct window
*w
)
10215 int i
, no_message_p
, window_height_changed_p
;
10217 /* Temporarily disable garbage collections while displaying the echo
10218 area. This is done because a GC can print a message itself.
10219 That message would modify the echo area buffer's contents while a
10220 redisplay of the buffer is going on, and seriously confuse
10222 ptrdiff_t count
= inhibit_garbage_collection ();
10224 /* If there is no message, we must call display_echo_area_1
10225 nevertheless because it resizes the window. But we will have to
10226 reset the echo_area_buffer in question to nil at the end because
10227 with_echo_area_buffer will sets it to an empty buffer. */
10228 i
= display_last_displayed_message_p
? 1 : 0;
10229 no_message_p
= NILP (echo_area_buffer
[i
]);
10231 window_height_changed_p
10232 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
10233 display_echo_area_1
,
10234 (intptr_t) w
, Qnil
, 0, 0);
10237 echo_area_buffer
[i
] = Qnil
;
10239 unbind_to (count
, Qnil
);
10240 return window_height_changed_p
;
10244 /* Helper for display_echo_area. Display the current buffer which
10245 contains the current echo area message in window W, a mini-window,
10246 a pointer to which is passed in A1. A2..A4 are currently not used.
10247 Change the height of W so that all of the message is displayed.
10248 Value is non-zero if height of W was changed. */
10251 display_echo_area_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10254 struct window
*w
= (struct window
*) i1
;
10255 Lisp_Object window
;
10256 struct text_pos start
;
10257 int window_height_changed_p
= 0;
10259 /* Do this before displaying, so that we have a large enough glyph
10260 matrix for the display. If we can't get enough space for the
10261 whole text, display the last N lines. That works by setting w->start. */
10262 window_height_changed_p
= resize_mini_window (w
, 0);
10264 /* Use the starting position chosen by resize_mini_window. */
10265 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
10268 clear_glyph_matrix (w
->desired_matrix
);
10269 XSETWINDOW (window
, w
);
10270 try_window (window
, start
, 0);
10272 return window_height_changed_p
;
10276 /* Resize the echo area window to exactly the size needed for the
10277 currently displayed message, if there is one. If a mini-buffer
10278 is active, don't shrink it. */
10281 resize_echo_area_exactly (void)
10283 if (BUFFERP (echo_area_buffer
[0])
10284 && WINDOWP (echo_area_window
))
10286 struct window
*w
= XWINDOW (echo_area_window
);
10288 Lisp_Object resize_exactly
;
10290 if (minibuf_level
== 0)
10291 resize_exactly
= Qt
;
10293 resize_exactly
= Qnil
;
10295 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
10296 (intptr_t) w
, resize_exactly
,
10300 ++windows_or_buffers_changed
;
10301 ++update_mode_lines
;
10302 redisplay_internal ();
10308 /* Callback function for with_echo_area_buffer, when used from
10309 resize_echo_area_exactly. A1 contains a pointer to the window to
10310 resize, EXACTLY non-nil means resize the mini-window exactly to the
10311 size of the text displayed. A3 and A4 are not used. Value is what
10312 resize_mini_window returns. */
10315 resize_mini_window_1 (ptrdiff_t a1
, Lisp_Object exactly
, ptrdiff_t a3
, ptrdiff_t a4
)
10318 return resize_mini_window ((struct window
*) i1
, !NILP (exactly
));
10322 /* Resize mini-window W to fit the size of its contents. EXACT_P
10323 means size the window exactly to the size needed. Otherwise, it's
10324 only enlarged until W's buffer is empty.
10326 Set W->start to the right place to begin display. If the whole
10327 contents fit, start at the beginning. Otherwise, start so as
10328 to make the end of the contents appear. This is particularly
10329 important for y-or-n-p, but seems desirable generally.
10331 Value is non-zero if the window height has been changed. */
10334 resize_mini_window (struct window
*w
, int exact_p
)
10336 struct frame
*f
= XFRAME (w
->frame
);
10337 int window_height_changed_p
= 0;
10339 eassert (MINI_WINDOW_P (w
));
10341 /* By default, start display at the beginning. */
10342 set_marker_both (w
->start
, w
->buffer
,
10343 BUF_BEGV (XBUFFER (w
->buffer
)),
10344 BUF_BEGV_BYTE (XBUFFER (w
->buffer
)));
10346 /* Don't resize windows while redisplaying a window; it would
10347 confuse redisplay functions when the size of the window they are
10348 displaying changes from under them. Such a resizing can happen,
10349 for instance, when which-func prints a long message while
10350 we are running fontification-functions. We're running these
10351 functions with safe_call which binds inhibit-redisplay to t. */
10352 if (!NILP (Vinhibit_redisplay
))
10355 /* Nil means don't try to resize. */
10356 if (NILP (Vresize_mini_windows
)
10357 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
10360 if (!FRAME_MINIBUF_ONLY_P (f
))
10363 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10364 int total_height
= WINDOW_TOTAL_LINES (root
) + WINDOW_TOTAL_LINES (w
);
10366 EMACS_INT max_height
;
10367 int unit
= FRAME_LINE_HEIGHT (f
);
10368 struct text_pos start
;
10369 struct buffer
*old_current_buffer
= NULL
;
10371 if (current_buffer
!= XBUFFER (w
->buffer
))
10373 old_current_buffer
= current_buffer
;
10374 set_buffer_internal (XBUFFER (w
->buffer
));
10377 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10379 /* Compute the max. number of lines specified by the user. */
10380 if (FLOATP (Vmax_mini_window_height
))
10381 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_LINES (f
);
10382 else if (INTEGERP (Vmax_mini_window_height
))
10383 max_height
= XINT (Vmax_mini_window_height
);
10385 max_height
= total_height
/ 4;
10387 /* Correct that max. height if it's bogus. */
10388 max_height
= max (1, max_height
);
10389 max_height
= min (total_height
, max_height
);
10391 /* Find out the height of the text in the window. */
10392 if (it
.line_wrap
== TRUNCATE
)
10397 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
10398 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
10399 height
= it
.current_y
+ last_height
;
10401 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
10402 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
10403 height
= (height
+ unit
- 1) / unit
;
10406 /* Compute a suitable window start. */
10407 if (height
> max_height
)
10409 height
= max_height
;
10410 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
10411 move_it_vertically_backward (&it
, (height
- 1) * unit
);
10412 start
= it
.current
.pos
;
10415 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
10416 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
10418 if (EQ (Vresize_mini_windows
, Qgrow_only
))
10420 /* Let it grow only, until we display an empty message, in which
10421 case the window shrinks again. */
10422 if (height
> WINDOW_TOTAL_LINES (w
))
10424 int old_height
= WINDOW_TOTAL_LINES (w
);
10425 freeze_window_starts (f
, 1);
10426 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10427 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10429 else if (height
< WINDOW_TOTAL_LINES (w
)
10430 && (exact_p
|| BEGV
== ZV
))
10432 int old_height
= WINDOW_TOTAL_LINES (w
);
10433 freeze_window_starts (f
, 0);
10434 shrink_mini_window (w
);
10435 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10440 /* Always resize to exact size needed. */
10441 if (height
> WINDOW_TOTAL_LINES (w
))
10443 int old_height
= WINDOW_TOTAL_LINES (w
);
10444 freeze_window_starts (f
, 1);
10445 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10446 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10448 else if (height
< WINDOW_TOTAL_LINES (w
))
10450 int old_height
= WINDOW_TOTAL_LINES (w
);
10451 freeze_window_starts (f
, 0);
10452 shrink_mini_window (w
);
10456 freeze_window_starts (f
, 1);
10457 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
10460 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
10464 if (old_current_buffer
)
10465 set_buffer_internal (old_current_buffer
);
10468 return window_height_changed_p
;
10472 /* Value is the current message, a string, or nil if there is no
10473 current message. */
10476 current_message (void)
10480 if (!BUFFERP (echo_area_buffer
[0]))
10484 with_echo_area_buffer (0, 0, current_message_1
,
10485 (intptr_t) &msg
, Qnil
, 0, 0);
10487 echo_area_buffer
[0] = Qnil
;
10495 current_message_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10498 Lisp_Object
*msg
= (Lisp_Object
*) i1
;
10501 *msg
= make_buffer_string (BEG
, Z
, 1);
10508 /* Push the current message on Vmessage_stack for later restoration
10509 by restore_message. Value is non-zero if the current message isn't
10510 empty. This is a relatively infrequent operation, so it's not
10511 worth optimizing. */
10514 push_message (void)
10516 Lisp_Object msg
= current_message ();
10517 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
10518 return STRINGP (msg
);
10522 /* Restore message display from the top of Vmessage_stack. */
10525 restore_message (void)
10529 eassert (CONSP (Vmessage_stack
));
10530 msg
= XCAR (Vmessage_stack
);
10532 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
10534 message3_nolog (msg
, 0, 0);
10538 /* Handler for record_unwind_protect calling pop_message. */
10541 pop_message_unwind (Lisp_Object dummy
)
10547 /* Pop the top-most entry off Vmessage_stack. */
10552 eassert (CONSP (Vmessage_stack
));
10553 Vmessage_stack
= XCDR (Vmessage_stack
);
10557 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
10558 exits. If the stack is not empty, we have a missing pop_message
10562 check_message_stack (void)
10564 if (!NILP (Vmessage_stack
))
10569 /* Truncate to NCHARS what will be displayed in the echo area the next
10570 time we display it---but don't redisplay it now. */
10573 truncate_echo_area (ptrdiff_t nchars
)
10576 echo_area_buffer
[0] = Qnil
;
10577 /* A null message buffer means that the frame hasn't really been
10578 initialized yet. Error messages get reported properly by
10579 cmd_error, so this must be just an informative message; toss it. */
10580 else if (!noninteractive
10582 && !NILP (echo_area_buffer
[0]))
10584 struct frame
*sf
= SELECTED_FRAME ();
10585 if (FRAME_MESSAGE_BUF (sf
))
10586 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
10591 /* Helper function for truncate_echo_area. Truncate the current
10592 message to at most NCHARS characters. */
10595 truncate_message_1 (ptrdiff_t nchars
, Lisp_Object a2
, ptrdiff_t a3
, ptrdiff_t a4
)
10597 if (BEG
+ nchars
< Z
)
10598 del_range (BEG
+ nchars
, Z
);
10600 echo_area_buffer
[0] = Qnil
;
10604 /* Set the current message to a substring of S or STRING.
10606 If STRING is a Lisp string, set the message to the first NBYTES
10607 bytes from STRING. NBYTES zero means use the whole string. If
10608 STRING is multibyte, the message will be displayed multibyte.
10610 If S is not null, set the message to the first LEN bytes of S. LEN
10611 zero means use the whole string. MULTIBYTE_P non-zero means S is
10612 multibyte. Display the message multibyte in that case.
10614 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
10615 to t before calling set_message_1 (which calls insert).
10619 set_message (const char *s
, Lisp_Object string
,
10620 ptrdiff_t nbytes
, int multibyte_p
)
10622 message_enable_multibyte
10623 = ((s
&& multibyte_p
)
10624 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
10626 with_echo_area_buffer (0, -1, set_message_1
,
10627 (intptr_t) s
, string
, nbytes
, multibyte_p
);
10628 message_buf_print
= 0;
10629 help_echo_showing_p
= 0;
10631 if (STRINGP (Vdebug_on_message
)
10632 && fast_string_match (Vdebug_on_message
, string
) >= 0)
10633 call_debugger (list2 (Qerror
, string
));
10637 /* Helper function for set_message. Arguments have the same meaning
10638 as there, with A1 corresponding to S and A2 corresponding to STRING
10639 This function is called with the echo area buffer being
10643 set_message_1 (ptrdiff_t a1
, Lisp_Object a2
, ptrdiff_t nbytes
, ptrdiff_t multibyte_p
)
10646 const char *s
= (const char *) i1
;
10647 const unsigned char *msg
= (const unsigned char *) s
;
10648 Lisp_Object string
= a2
;
10650 /* Change multibyteness of the echo buffer appropriately. */
10651 if (message_enable_multibyte
10652 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10653 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
10655 bset_truncate_lines (current_buffer
, message_truncate_lines
? Qt
: Qnil
);
10656 if (!NILP (BVAR (current_buffer
, bidi_display_reordering
)))
10657 bset_bidi_paragraph_direction (current_buffer
, Qleft_to_right
);
10659 /* Insert new message at BEG. */
10660 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10662 if (STRINGP (string
))
10667 nbytes
= SBYTES (string
);
10668 nchars
= string_byte_to_char (string
, nbytes
);
10670 /* This function takes care of single/multibyte conversion. We
10671 just have to ensure that the echo area buffer has the right
10672 setting of enable_multibyte_characters. */
10673 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
10678 nbytes
= strlen (s
);
10680 if (multibyte_p
&& NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10682 /* Convert from multi-byte to single-byte. */
10687 /* Convert a multibyte string to single-byte. */
10688 for (i
= 0; i
< nbytes
; i
+= n
)
10690 c
= string_char_and_length (msg
+ i
, &n
);
10691 work
[0] = (ASCII_CHAR_P (c
)
10693 : multibyte_char_to_unibyte (c
));
10694 insert_1_both (work
, 1, 1, 1, 0, 0);
10697 else if (!multibyte_p
10698 && !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10700 /* Convert from single-byte to multi-byte. */
10703 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
10705 /* Convert a single-byte string to multibyte. */
10706 for (i
= 0; i
< nbytes
; i
++)
10709 MAKE_CHAR_MULTIBYTE (c
);
10710 n
= CHAR_STRING (c
, str
);
10711 insert_1_both ((char *) str
, 1, n
, 1, 0, 0);
10715 insert_1 (s
, nbytes
, 1, 0, 0);
10722 /* Clear messages. CURRENT_P non-zero means clear the current
10723 message. LAST_DISPLAYED_P non-zero means clear the message
10727 clear_message (int current_p
, int last_displayed_p
)
10731 echo_area_buffer
[0] = Qnil
;
10732 message_cleared_p
= 1;
10735 if (last_displayed_p
)
10736 echo_area_buffer
[1] = Qnil
;
10738 message_buf_print
= 0;
10741 /* Clear garbaged frames.
10743 This function is used where the old redisplay called
10744 redraw_garbaged_frames which in turn called redraw_frame which in
10745 turn called clear_frame. The call to clear_frame was a source of
10746 flickering. I believe a clear_frame is not necessary. It should
10747 suffice in the new redisplay to invalidate all current matrices,
10748 and ensure a complete redisplay of all windows. */
10751 clear_garbaged_frames (void)
10753 if (frame_garbaged
)
10755 Lisp_Object tail
, frame
;
10756 int changed_count
= 0;
10758 FOR_EACH_FRAME (tail
, frame
)
10760 struct frame
*f
= XFRAME (frame
);
10762 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
10767 f
->force_flush_display_p
= 1;
10769 clear_current_matrices (f
);
10776 frame_garbaged
= 0;
10778 ++windows_or_buffers_changed
;
10783 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
10784 is non-zero update selected_frame. Value is non-zero if the
10785 mini-windows height has been changed. */
10788 echo_area_display (int update_frame_p
)
10790 Lisp_Object mini_window
;
10793 int window_height_changed_p
= 0;
10794 struct frame
*sf
= SELECTED_FRAME ();
10796 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10797 w
= XWINDOW (mini_window
);
10798 f
= XFRAME (WINDOW_FRAME (w
));
10800 /* Don't display if frame is invisible or not yet initialized. */
10801 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
10804 #ifdef HAVE_WINDOW_SYSTEM
10805 /* When Emacs starts, selected_frame may be the initial terminal
10806 frame. If we let this through, a message would be displayed on
10808 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
10810 #endif /* HAVE_WINDOW_SYSTEM */
10812 /* Redraw garbaged frames. */
10813 clear_garbaged_frames ();
10815 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
10817 echo_area_window
= mini_window
;
10818 window_height_changed_p
= display_echo_area (w
);
10819 w
->must_be_updated_p
= 1;
10821 /* Update the display, unless called from redisplay_internal.
10822 Also don't update the screen during redisplay itself. The
10823 update will happen at the end of redisplay, and an update
10824 here could cause confusion. */
10825 if (update_frame_p
&& !redisplaying_p
)
10829 /* If the display update has been interrupted by pending
10830 input, update mode lines in the frame. Due to the
10831 pending input, it might have been that redisplay hasn't
10832 been called, so that mode lines above the echo area are
10833 garbaged. This looks odd, so we prevent it here. */
10834 if (!display_completed
)
10835 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
10837 if (window_height_changed_p
10838 /* Don't do this if Emacs is shutting down. Redisplay
10839 needs to run hooks. */
10840 && !NILP (Vrun_hooks
))
10842 /* Must update other windows. Likewise as in other
10843 cases, don't let this update be interrupted by
10845 ptrdiff_t count
= SPECPDL_INDEX ();
10846 specbind (Qredisplay_dont_pause
, Qt
);
10847 windows_or_buffers_changed
= 1;
10848 redisplay_internal ();
10849 unbind_to (count
, Qnil
);
10851 else if (FRAME_WINDOW_P (f
) && n
== 0)
10853 /* Window configuration is the same as before.
10854 Can do with a display update of the echo area,
10855 unless we displayed some mode lines. */
10856 update_single_window (w
, 1);
10857 FRAME_RIF (f
)->flush_display (f
);
10860 update_frame (f
, 1, 1);
10862 /* If cursor is in the echo area, make sure that the next
10863 redisplay displays the minibuffer, so that the cursor will
10864 be replaced with what the minibuffer wants. */
10865 if (cursor_in_echo_area
)
10866 ++windows_or_buffers_changed
;
10869 else if (!EQ (mini_window
, selected_window
))
10870 windows_or_buffers_changed
++;
10872 /* Last displayed message is now the current message. */
10873 echo_area_buffer
[1] = echo_area_buffer
[0];
10874 /* Inform read_char that we're not echoing. */
10875 echo_message_buffer
= Qnil
;
10877 /* Prevent redisplay optimization in redisplay_internal by resetting
10878 this_line_start_pos. This is done because the mini-buffer now
10879 displays the message instead of its buffer text. */
10880 if (EQ (mini_window
, selected_window
))
10881 CHARPOS (this_line_start_pos
) = 0;
10883 return window_height_changed_p
;
10886 /* Nonzero if the current window's buffer is shown in more than one
10887 window and was modified since last redisplay. */
10890 buffer_shared_and_changed (void)
10892 return (buffer_window_count (current_buffer
) > 1
10893 && UNCHANGED_MODIFIED
< MODIFF
);
10896 /* Nonzero if W doesn't reflect the actual state of current buffer due
10897 to its text or overlays change. FIXME: this may be called when
10898 XBUFFER (w->buffer) != current_buffer, which looks suspicious. */
10901 window_outdated (struct window
*w
)
10903 return (w
->last_modified
< MODIFF
10904 || w
->last_overlay_modified
< OVERLAY_MODIFF
);
10907 /* Nonzero if W's buffer was changed but not saved or Transient Mark mode
10908 is enabled and mark of W's buffer was changed since last W's update. */
10911 window_buffer_changed (struct window
*w
)
10913 struct buffer
*b
= XBUFFER (w
->buffer
);
10915 eassert (BUFFER_LIVE_P (b
));
10917 return (((BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)) != w
->last_had_star
)
10918 || ((!NILP (Vtransient_mark_mode
) && !NILP (BVAR (b
, mark_active
)))
10919 != !NILP (w
->region_showing
)));
10922 /* Nonzero if W has %c in its mode line and mode line should be updated. */
10925 mode_line_update_needed (struct window
*w
)
10927 return (!NILP (w
->column_number_displayed
)
10928 && !(PT
== w
->last_point
&& !window_outdated (w
))
10929 && (XFASTINT (w
->column_number_displayed
) != current_column ()));
10932 /***********************************************************************
10933 Mode Lines and Frame Titles
10934 ***********************************************************************/
10936 /* A buffer for constructing non-propertized mode-line strings and
10937 frame titles in it; allocated from the heap in init_xdisp and
10938 resized as needed in store_mode_line_noprop_char. */
10940 static char *mode_line_noprop_buf
;
10942 /* The buffer's end, and a current output position in it. */
10944 static char *mode_line_noprop_buf_end
;
10945 static char *mode_line_noprop_ptr
;
10947 #define MODE_LINE_NOPROP_LEN(start) \
10948 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
10951 MODE_LINE_DISPLAY
= 0,
10955 } mode_line_target
;
10957 /* Alist that caches the results of :propertize.
10958 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
10959 static Lisp_Object mode_line_proptrans_alist
;
10961 /* List of strings making up the mode-line. */
10962 static Lisp_Object mode_line_string_list
;
10964 /* Base face property when building propertized mode line string. */
10965 static Lisp_Object mode_line_string_face
;
10966 static Lisp_Object mode_line_string_face_prop
;
10969 /* Unwind data for mode line strings */
10971 static Lisp_Object Vmode_line_unwind_vector
;
10974 format_mode_line_unwind_data (struct frame
*target_frame
,
10975 struct buffer
*obuf
,
10977 int save_proptrans
)
10979 Lisp_Object vector
, tmp
;
10981 /* Reduce consing by keeping one vector in
10982 Vwith_echo_area_save_vector. */
10983 vector
= Vmode_line_unwind_vector
;
10984 Vmode_line_unwind_vector
= Qnil
;
10987 vector
= Fmake_vector (make_number (10), Qnil
);
10989 ASET (vector
, 0, make_number (mode_line_target
));
10990 ASET (vector
, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
10991 ASET (vector
, 2, mode_line_string_list
);
10992 ASET (vector
, 3, save_proptrans
? mode_line_proptrans_alist
: Qt
);
10993 ASET (vector
, 4, mode_line_string_face
);
10994 ASET (vector
, 5, mode_line_string_face_prop
);
10997 XSETBUFFER (tmp
, obuf
);
11000 ASET (vector
, 6, tmp
);
11001 ASET (vector
, 7, owin
);
11004 /* Similarly to `with-selected-window', if the operation selects
11005 a window on another frame, we must restore that frame's
11006 selected window, and (for a tty) the top-frame. */
11007 ASET (vector
, 8, target_frame
->selected_window
);
11008 if (FRAME_TERMCAP_P (target_frame
))
11009 ASET (vector
, 9, FRAME_TTY (target_frame
)->top_frame
);
11016 unwind_format_mode_line (Lisp_Object vector
)
11018 Lisp_Object old_window
= AREF (vector
, 7);
11019 Lisp_Object target_frame_window
= AREF (vector
, 8);
11020 Lisp_Object old_top_frame
= AREF (vector
, 9);
11022 mode_line_target
= XINT (AREF (vector
, 0));
11023 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
11024 mode_line_string_list
= AREF (vector
, 2);
11025 if (! EQ (AREF (vector
, 3), Qt
))
11026 mode_line_proptrans_alist
= AREF (vector
, 3);
11027 mode_line_string_face
= AREF (vector
, 4);
11028 mode_line_string_face_prop
= AREF (vector
, 5);
11030 /* Select window before buffer, since it may change the buffer. */
11031 if (!NILP (old_window
))
11033 /* If the operation that we are unwinding had selected a window
11034 on a different frame, reset its frame-selected-window. For a
11035 text terminal, reset its top-frame if necessary. */
11036 if (!NILP (target_frame_window
))
11039 = WINDOW_FRAME (XWINDOW (target_frame_window
));
11041 if (!EQ (frame
, WINDOW_FRAME (XWINDOW (old_window
))))
11042 Fselect_window (target_frame_window
, Qt
);
11044 if (!NILP (old_top_frame
) && !EQ (old_top_frame
, frame
))
11045 Fselect_frame (old_top_frame
, Qt
);
11048 Fselect_window (old_window
, Qt
);
11051 if (!NILP (AREF (vector
, 6)))
11053 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
11054 ASET (vector
, 6, Qnil
);
11057 Vmode_line_unwind_vector
= vector
;
11062 /* Store a single character C for the frame title in mode_line_noprop_buf.
11063 Re-allocate mode_line_noprop_buf if necessary. */
11066 store_mode_line_noprop_char (char c
)
11068 /* If output position has reached the end of the allocated buffer,
11069 increase the buffer's size. */
11070 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
11072 ptrdiff_t len
= MODE_LINE_NOPROP_LEN (0);
11073 ptrdiff_t size
= len
;
11074 mode_line_noprop_buf
=
11075 xpalloc (mode_line_noprop_buf
, &size
, 1, STRING_BYTES_BOUND
, 1);
11076 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
11077 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
11080 *mode_line_noprop_ptr
++ = c
;
11084 /* Store part of a frame title in mode_line_noprop_buf, beginning at
11085 mode_line_noprop_ptr. STRING is the string to store. Do not copy
11086 characters that yield more columns than PRECISION; PRECISION <= 0
11087 means copy the whole string. Pad with spaces until FIELD_WIDTH
11088 number of characters have been copied; FIELD_WIDTH <= 0 means don't
11089 pad. Called from display_mode_element when it is used to build a
11093 store_mode_line_noprop (const char *string
, int field_width
, int precision
)
11095 const unsigned char *str
= (const unsigned char *) string
;
11097 ptrdiff_t dummy
, nbytes
;
11099 /* Copy at most PRECISION chars from STR. */
11100 nbytes
= strlen (string
);
11101 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
11103 store_mode_line_noprop_char (*str
++);
11105 /* Fill up with spaces until FIELD_WIDTH reached. */
11106 while (field_width
> 0
11107 && n
< field_width
)
11109 store_mode_line_noprop_char (' ');
11116 /***********************************************************************
11118 ***********************************************************************/
11120 #ifdef HAVE_WINDOW_SYSTEM
11122 /* Set the title of FRAME, if it has changed. The title format is
11123 Vicon_title_format if FRAME is iconified, otherwise it is
11124 frame_title_format. */
11127 x_consider_frame_title (Lisp_Object frame
)
11129 struct frame
*f
= XFRAME (frame
);
11131 if (FRAME_WINDOW_P (f
)
11132 || FRAME_MINIBUF_ONLY_P (f
)
11133 || f
->explicit_name
)
11135 /* Do we have more than one visible frame on this X display? */
11136 Lisp_Object tail
, other_frame
, fmt
;
11137 ptrdiff_t title_start
;
11141 ptrdiff_t count
= SPECPDL_INDEX ();
11143 FOR_EACH_FRAME (tail
, other_frame
)
11145 struct frame
*tf
= XFRAME (other_frame
);
11148 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
11149 && !FRAME_MINIBUF_ONLY_P (tf
)
11150 && !EQ (other_frame
, tip_frame
)
11151 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
11155 /* Set global variable indicating that multiple frames exist. */
11156 multiple_frames
= CONSP (tail
);
11158 /* Switch to the buffer of selected window of the frame. Set up
11159 mode_line_target so that display_mode_element will output into
11160 mode_line_noprop_buf; then display the title. */
11161 record_unwind_protect (unwind_format_mode_line
,
11162 format_mode_line_unwind_data
11163 (f
, current_buffer
, selected_window
, 0));
11165 Fselect_window (f
->selected_window
, Qt
);
11166 set_buffer_internal_1
11167 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
11168 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
11170 mode_line_target
= MODE_LINE_TITLE
;
11171 title_start
= MODE_LINE_NOPROP_LEN (0);
11172 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
11173 NULL
, DEFAULT_FACE_ID
);
11174 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
11175 len
= MODE_LINE_NOPROP_LEN (title_start
);
11176 title
= mode_line_noprop_buf
+ title_start
;
11177 unbind_to (count
, Qnil
);
11179 /* Set the title only if it's changed. This avoids consing in
11180 the common case where it hasn't. (If it turns out that we've
11181 already wasted too much time by walking through the list with
11182 display_mode_element, then we might need to optimize at a
11183 higher level than this.) */
11184 if (! STRINGP (f
->name
)
11185 || SBYTES (f
->name
) != len
11186 || memcmp (title
, SDATA (f
->name
), len
) != 0)
11187 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
11191 #endif /* not HAVE_WINDOW_SYSTEM */
11194 /***********************************************************************
11196 ***********************************************************************/
11199 /* Prepare for redisplay by updating menu-bar item lists when
11200 appropriate. This can call eval. */
11203 prepare_menu_bars (void)
11206 struct gcpro gcpro1
, gcpro2
;
11208 Lisp_Object tooltip_frame
;
11210 #ifdef HAVE_WINDOW_SYSTEM
11211 tooltip_frame
= tip_frame
;
11213 tooltip_frame
= Qnil
;
11216 /* Update all frame titles based on their buffer names, etc. We do
11217 this before the menu bars so that the buffer-menu will show the
11218 up-to-date frame titles. */
11219 #ifdef HAVE_WINDOW_SYSTEM
11220 if (windows_or_buffers_changed
|| update_mode_lines
)
11222 Lisp_Object tail
, frame
;
11224 FOR_EACH_FRAME (tail
, frame
)
11226 f
= XFRAME (frame
);
11227 if (!EQ (frame
, tooltip_frame
)
11228 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
11229 x_consider_frame_title (frame
);
11232 #endif /* HAVE_WINDOW_SYSTEM */
11234 /* Update the menu bar item lists, if appropriate. This has to be
11235 done before any actual redisplay or generation of display lines. */
11236 all_windows
= (update_mode_lines
11237 || buffer_shared_and_changed ()
11238 || windows_or_buffers_changed
);
11241 Lisp_Object tail
, frame
;
11242 ptrdiff_t count
= SPECPDL_INDEX ();
11243 /* 1 means that update_menu_bar has run its hooks
11244 so any further calls to update_menu_bar shouldn't do so again. */
11245 int menu_bar_hooks_run
= 0;
11247 record_unwind_save_match_data ();
11249 FOR_EACH_FRAME (tail
, frame
)
11251 f
= XFRAME (frame
);
11253 /* Ignore tooltip frame. */
11254 if (EQ (frame
, tooltip_frame
))
11257 /* If a window on this frame changed size, report that to
11258 the user and clear the size-change flag. */
11259 if (FRAME_WINDOW_SIZES_CHANGED (f
))
11261 Lisp_Object functions
;
11263 /* Clear flag first in case we get an error below. */
11264 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
11265 functions
= Vwindow_size_change_functions
;
11266 GCPRO2 (tail
, functions
);
11268 while (CONSP (functions
))
11270 if (!EQ (XCAR (functions
), Qt
))
11271 call1 (XCAR (functions
), frame
);
11272 functions
= XCDR (functions
);
11278 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
11279 #ifdef HAVE_WINDOW_SYSTEM
11280 update_tool_bar (f
, 0);
11283 if (windows_or_buffers_changed
11286 (f
, Fbuffer_modified_p (XWINDOW (f
->selected_window
)->buffer
));
11291 unbind_to (count
, Qnil
);
11295 struct frame
*sf
= SELECTED_FRAME ();
11296 update_menu_bar (sf
, 1, 0);
11297 #ifdef HAVE_WINDOW_SYSTEM
11298 update_tool_bar (sf
, 1);
11304 /* Update the menu bar item list for frame F. This has to be done
11305 before we start to fill in any display lines, because it can call
11308 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
11310 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
11311 already ran the menu bar hooks for this redisplay, so there
11312 is no need to run them again. The return value is the
11313 updated value of this flag, to pass to the next call. */
11316 update_menu_bar (struct frame
*f
, int save_match_data
, int hooks_run
)
11318 Lisp_Object window
;
11319 register struct window
*w
;
11321 /* If called recursively during a menu update, do nothing. This can
11322 happen when, for instance, an activate-menubar-hook causes a
11324 if (inhibit_menubar_update
)
11327 window
= FRAME_SELECTED_WINDOW (f
);
11328 w
= XWINDOW (window
);
11330 if (FRAME_WINDOW_P (f
)
11332 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11333 || defined (HAVE_NS) || defined (USE_GTK)
11334 FRAME_EXTERNAL_MENU_BAR (f
)
11336 FRAME_MENU_BAR_LINES (f
) > 0
11338 : FRAME_MENU_BAR_LINES (f
) > 0)
11340 /* If the user has switched buffers or windows, we need to
11341 recompute to reflect the new bindings. But we'll
11342 recompute when update_mode_lines is set too; that means
11343 that people can use force-mode-line-update to request
11344 that the menu bar be recomputed. The adverse effect on
11345 the rest of the redisplay algorithm is about the same as
11346 windows_or_buffers_changed anyway. */
11347 if (windows_or_buffers_changed
11348 /* This used to test w->update_mode_line, but we believe
11349 there is no need to recompute the menu in that case. */
11350 || update_mode_lines
11351 || window_buffer_changed (w
))
11353 struct buffer
*prev
= current_buffer
;
11354 ptrdiff_t count
= SPECPDL_INDEX ();
11356 specbind (Qinhibit_menubar_update
, Qt
);
11358 set_buffer_internal_1 (XBUFFER (w
->buffer
));
11359 if (save_match_data
)
11360 record_unwind_save_match_data ();
11361 if (NILP (Voverriding_local_map_menu_flag
))
11363 specbind (Qoverriding_terminal_local_map
, Qnil
);
11364 specbind (Qoverriding_local_map
, Qnil
);
11369 /* Run the Lucid hook. */
11370 safe_run_hooks (Qactivate_menubar_hook
);
11372 /* If it has changed current-menubar from previous value,
11373 really recompute the menu-bar from the value. */
11374 if (! NILP (Vlucid_menu_bar_dirty_flag
))
11375 call0 (Qrecompute_lucid_menubar
);
11377 safe_run_hooks (Qmenu_bar_update_hook
);
11382 XSETFRAME (Vmenu_updating_frame
, f
);
11383 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
11385 /* Redisplay the menu bar in case we changed it. */
11386 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
11387 || defined (HAVE_NS) || defined (USE_GTK)
11388 if (FRAME_WINDOW_P (f
))
11390 #if defined (HAVE_NS)
11391 /* All frames on Mac OS share the same menubar. So only
11392 the selected frame should be allowed to set it. */
11393 if (f
== SELECTED_FRAME ())
11395 set_frame_menubar (f
, 0, 0);
11398 /* On a terminal screen, the menu bar is an ordinary screen
11399 line, and this makes it get updated. */
11400 w
->update_mode_line
= 1;
11401 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11402 /* In the non-toolkit version, the menu bar is an ordinary screen
11403 line, and this makes it get updated. */
11404 w
->update_mode_line
= 1;
11405 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
11407 unbind_to (count
, Qnil
);
11408 set_buffer_internal_1 (prev
);
11417 /***********************************************************************
11419 ***********************************************************************/
11421 #ifdef HAVE_WINDOW_SYSTEM
11424 Nominal cursor position -- where to draw output.
11425 HPOS and VPOS are window relative glyph matrix coordinates.
11426 X and Y are window relative pixel coordinates. */
11428 struct cursor_pos output_cursor
;
11432 Set the global variable output_cursor to CURSOR. All cursor
11433 positions are relative to updated_window. */
11436 set_output_cursor (struct cursor_pos
*cursor
)
11438 output_cursor
.hpos
= cursor
->hpos
;
11439 output_cursor
.vpos
= cursor
->vpos
;
11440 output_cursor
.x
= cursor
->x
;
11441 output_cursor
.y
= cursor
->y
;
11446 Set a nominal cursor position.
11448 HPOS and VPOS are column/row positions in a window glyph matrix. X
11449 and Y are window text area relative pixel positions.
11451 If this is done during an update, updated_window will contain the
11452 window that is being updated and the position is the future output
11453 cursor position for that window. If updated_window is null, use
11454 selected_window and display the cursor at the given position. */
11457 x_cursor_to (int vpos
, int hpos
, int y
, int x
)
11461 /* If updated_window is not set, work on selected_window. */
11462 if (updated_window
)
11463 w
= updated_window
;
11465 w
= XWINDOW (selected_window
);
11467 /* Set the output cursor. */
11468 output_cursor
.hpos
= hpos
;
11469 output_cursor
.vpos
= vpos
;
11470 output_cursor
.x
= x
;
11471 output_cursor
.y
= y
;
11473 /* If not called as part of an update, really display the cursor.
11474 This will also set the cursor position of W. */
11475 if (updated_window
== NULL
)
11478 display_and_set_cursor (w
, 1, hpos
, vpos
, x
, y
);
11479 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
11480 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
11485 #endif /* HAVE_WINDOW_SYSTEM */
11488 /***********************************************************************
11490 ***********************************************************************/
11492 #ifdef HAVE_WINDOW_SYSTEM
11494 /* Where the mouse was last time we reported a mouse event. */
11496 FRAME_PTR last_mouse_frame
;
11498 /* Tool-bar item index of the item on which a mouse button was pressed
11501 int last_tool_bar_item
;
11503 /* Select `frame' temporarily without running all the code in
11505 FIXME: Maybe do_switch_frame should be trimmed down similarly
11506 when `norecord' is set. */
11508 fast_set_selected_frame (Lisp_Object frame
)
11510 if (!EQ (selected_frame
, frame
))
11512 selected_frame
= frame
;
11513 selected_window
= XFRAME (frame
)->selected_window
;
11518 /* Update the tool-bar item list for frame F. This has to be done
11519 before we start to fill in any display lines. Called from
11520 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
11521 and restore it here. */
11524 update_tool_bar (struct frame
*f
, int save_match_data
)
11526 #if defined (USE_GTK) || defined (HAVE_NS)
11527 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
11529 int do_update
= WINDOWP (f
->tool_bar_window
)
11530 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0;
11535 Lisp_Object window
;
11538 window
= FRAME_SELECTED_WINDOW (f
);
11539 w
= XWINDOW (window
);
11541 /* If the user has switched buffers or windows, we need to
11542 recompute to reflect the new bindings. But we'll
11543 recompute when update_mode_lines is set too; that means
11544 that people can use force-mode-line-update to request
11545 that the menu bar be recomputed. The adverse effect on
11546 the rest of the redisplay algorithm is about the same as
11547 windows_or_buffers_changed anyway. */
11548 if (windows_or_buffers_changed
11549 || w
->update_mode_line
11550 || update_mode_lines
11551 || window_buffer_changed (w
))
11553 struct buffer
*prev
= current_buffer
;
11554 ptrdiff_t count
= SPECPDL_INDEX ();
11555 Lisp_Object frame
, new_tool_bar
;
11556 int new_n_tool_bar
;
11557 struct gcpro gcpro1
;
11559 /* Set current_buffer to the buffer of the selected
11560 window of the frame, so that we get the right local
11562 set_buffer_internal_1 (XBUFFER (w
->buffer
));
11564 /* Save match data, if we must. */
11565 if (save_match_data
)
11566 record_unwind_save_match_data ();
11568 /* Make sure that we don't accidentally use bogus keymaps. */
11569 if (NILP (Voverriding_local_map_menu_flag
))
11571 specbind (Qoverriding_terminal_local_map
, Qnil
);
11572 specbind (Qoverriding_local_map
, Qnil
);
11575 GCPRO1 (new_tool_bar
);
11577 /* We must temporarily set the selected frame to this frame
11578 before calling tool_bar_items, because the calculation of
11579 the tool-bar keymap uses the selected frame (see
11580 `tool-bar-make-keymap' in tool-bar.el). */
11581 eassert (EQ (selected_window
,
11582 /* Since we only explicitly preserve selected_frame,
11583 check that selected_window would be redundant. */
11584 XFRAME (selected_frame
)->selected_window
));
11585 record_unwind_protect (fast_set_selected_frame
, selected_frame
);
11586 XSETFRAME (frame
, f
);
11587 fast_set_selected_frame (frame
);
11589 /* Build desired tool-bar items from keymaps. */
11591 = tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
11594 /* Redisplay the tool-bar if we changed it. */
11595 if (new_n_tool_bar
!= f
->n_tool_bar_items
11596 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
11598 /* Redisplay that happens asynchronously due to an expose event
11599 may access f->tool_bar_items. Make sure we update both
11600 variables within BLOCK_INPUT so no such event interrupts. */
11602 fset_tool_bar_items (f
, new_tool_bar
);
11603 f
->n_tool_bar_items
= new_n_tool_bar
;
11604 w
->update_mode_line
= 1;
11610 unbind_to (count
, Qnil
);
11611 set_buffer_internal_1 (prev
);
11617 /* Set F->desired_tool_bar_string to a Lisp string representing frame
11618 F's desired tool-bar contents. F->tool_bar_items must have
11619 been set up previously by calling prepare_menu_bars. */
11622 build_desired_tool_bar_string (struct frame
*f
)
11624 int i
, size
, size_needed
;
11625 struct gcpro gcpro1
, gcpro2
, gcpro3
;
11626 Lisp_Object image
, plist
, props
;
11628 image
= plist
= props
= Qnil
;
11629 GCPRO3 (image
, plist
, props
);
11631 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
11632 Otherwise, make a new string. */
11634 /* The size of the string we might be able to reuse. */
11635 size
= (STRINGP (f
->desired_tool_bar_string
)
11636 ? SCHARS (f
->desired_tool_bar_string
)
11639 /* We need one space in the string for each image. */
11640 size_needed
= f
->n_tool_bar_items
;
11642 /* Reuse f->desired_tool_bar_string, if possible. */
11643 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
11644 fset_desired_tool_bar_string
11645 (f
, Fmake_string (make_number (size_needed
), make_number (' ')));
11648 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
11649 Fremove_text_properties (make_number (0), make_number (size
),
11650 props
, f
->desired_tool_bar_string
);
11653 /* Put a `display' property on the string for the images to display,
11654 put a `menu_item' property on tool-bar items with a value that
11655 is the index of the item in F's tool-bar item vector. */
11656 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
11658 #define PROP(IDX) \
11659 AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
11661 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
11662 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
11663 int hmargin
, vmargin
, relief
, idx
, end
;
11665 /* If image is a vector, choose the image according to the
11667 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
11668 if (VECTORP (image
))
11672 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
11673 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
11676 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
11677 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
11679 eassert (ASIZE (image
) >= idx
);
11680 image
= AREF (image
, idx
);
11685 /* Ignore invalid image specifications. */
11686 if (!valid_image_p (image
))
11689 /* Display the tool-bar button pressed, or depressed. */
11690 plist
= Fcopy_sequence (XCDR (image
));
11692 /* Compute margin and relief to draw. */
11693 relief
= (tool_bar_button_relief
>= 0
11694 ? tool_bar_button_relief
11695 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
11696 hmargin
= vmargin
= relief
;
11698 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
,
11699 INT_MAX
- max (hmargin
, vmargin
)))
11701 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
11702 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
11704 else if (CONSP (Vtool_bar_button_margin
))
11706 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
),
11707 INT_MAX
- hmargin
))
11708 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
11710 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
),
11711 INT_MAX
- vmargin
))
11712 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
11715 if (auto_raise_tool_bar_buttons_p
)
11717 /* Add a `:relief' property to the image spec if the item is
11721 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
11728 /* If image is selected, display it pressed, i.e. with a
11729 negative relief. If it's not selected, display it with a
11731 plist
= Fplist_put (plist
, QCrelief
,
11733 ? make_number (-relief
)
11734 : make_number (relief
)));
11739 /* Put a margin around the image. */
11740 if (hmargin
|| vmargin
)
11742 if (hmargin
== vmargin
)
11743 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
11745 plist
= Fplist_put (plist
, QCmargin
,
11746 Fcons (make_number (hmargin
),
11747 make_number (vmargin
)));
11750 /* If button is not enabled, and we don't have special images
11751 for the disabled state, make the image appear disabled by
11752 applying an appropriate algorithm to it. */
11753 if (!enabled_p
&& idx
< 0)
11754 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
11756 /* Put a `display' text property on the string for the image to
11757 display. Put a `menu-item' property on the string that gives
11758 the start of this item's properties in the tool-bar items
11760 image
= Fcons (Qimage
, plist
);
11761 props
= list4 (Qdisplay
, image
,
11762 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
11764 /* Let the last image hide all remaining spaces in the tool bar
11765 string. The string can be longer than needed when we reuse a
11766 previous string. */
11767 if (i
+ 1 == f
->n_tool_bar_items
)
11768 end
= SCHARS (f
->desired_tool_bar_string
);
11771 Fadd_text_properties (make_number (i
), make_number (end
),
11772 props
, f
->desired_tool_bar_string
);
11780 /* Display one line of the tool-bar of frame IT->f.
11782 HEIGHT specifies the desired height of the tool-bar line.
11783 If the actual height of the glyph row is less than HEIGHT, the
11784 row's height is increased to HEIGHT, and the icons are centered
11785 vertically in the new height.
11787 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
11788 count a final empty row in case the tool-bar width exactly matches
11793 display_tool_bar_line (struct it
*it
, int height
)
11795 struct glyph_row
*row
= it
->glyph_row
;
11796 int max_x
= it
->last_visible_x
;
11797 struct glyph
*last
;
11799 prepare_desired_row (row
);
11800 row
->y
= it
->current_y
;
11802 /* Note that this isn't made use of if the face hasn't a box,
11803 so there's no need to check the face here. */
11804 it
->start_of_box_run_p
= 1;
11806 while (it
->current_x
< max_x
)
11808 int x
, n_glyphs_before
, i
, nglyphs
;
11809 struct it it_before
;
11811 /* Get the next display element. */
11812 if (!get_next_display_element (it
))
11814 /* Don't count empty row if we are counting needed tool-bar lines. */
11815 if (height
< 0 && !it
->hpos
)
11820 /* Produce glyphs. */
11821 n_glyphs_before
= row
->used
[TEXT_AREA
];
11824 PRODUCE_GLYPHS (it
);
11826 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
11828 x
= it_before
.current_x
;
11829 while (i
< nglyphs
)
11831 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
11833 if (x
+ glyph
->pixel_width
> max_x
)
11835 /* Glyph doesn't fit on line. Backtrack. */
11836 row
->used
[TEXT_AREA
] = n_glyphs_before
;
11838 /* If this is the only glyph on this line, it will never fit on the
11839 tool-bar, so skip it. But ensure there is at least one glyph,
11840 so we don't accidentally disable the tool-bar. */
11841 if (n_glyphs_before
== 0
11842 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
11848 x
+= glyph
->pixel_width
;
11852 /* Stop at line end. */
11853 if (ITERATOR_AT_END_OF_LINE_P (it
))
11856 set_iterator_to_next (it
, 1);
11861 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
11863 /* Use default face for the border below the tool bar.
11865 FIXME: When auto-resize-tool-bars is grow-only, there is
11866 no additional border below the possibly empty tool-bar lines.
11867 So to make the extra empty lines look "normal", we have to
11868 use the tool-bar face for the border too. */
11869 if (!row
->displays_text_p
&& !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
11870 it
->face_id
= DEFAULT_FACE_ID
;
11872 extend_face_to_end_of_line (it
);
11873 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
11874 last
->right_box_line_p
= 1;
11875 if (last
== row
->glyphs
[TEXT_AREA
])
11876 last
->left_box_line_p
= 1;
11878 /* Make line the desired height and center it vertically. */
11879 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
11881 /* Don't add more than one line height. */
11882 height
%= FRAME_LINE_HEIGHT (it
->f
);
11883 it
->max_ascent
+= height
/ 2;
11884 it
->max_descent
+= (height
+ 1) / 2;
11887 compute_line_metrics (it
);
11889 /* If line is empty, make it occupy the rest of the tool-bar. */
11890 if (!row
->displays_text_p
)
11892 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
11893 row
->visible_height
= row
->height
;
11894 row
->ascent
= row
->phys_ascent
= 0;
11895 row
->extra_line_spacing
= 0;
11898 row
->full_width_p
= 1;
11899 row
->continued_p
= 0;
11900 row
->truncated_on_left_p
= 0;
11901 row
->truncated_on_right_p
= 0;
11903 it
->current_x
= it
->hpos
= 0;
11904 it
->current_y
+= row
->height
;
11910 /* Max tool-bar height. */
11912 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
11913 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
11915 /* Value is the number of screen lines needed to make all tool-bar
11916 items of frame F visible. The number of actual rows needed is
11917 returned in *N_ROWS if non-NULL. */
11920 tool_bar_lines_needed (struct frame
*f
, int *n_rows
)
11922 struct window
*w
= XWINDOW (f
->tool_bar_window
);
11924 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
11925 the desired matrix, so use (unused) mode-line row as temporary row to
11926 avoid destroying the first tool-bar row. */
11927 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
11929 /* Initialize an iterator for iteration over
11930 F->desired_tool_bar_string in the tool-bar window of frame F. */
11931 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
11932 it
.first_visible_x
= 0;
11933 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
11934 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
11935 it
.paragraph_embedding
= L2R
;
11937 while (!ITERATOR_AT_END_P (&it
))
11939 clear_glyph_row (temp_row
);
11940 it
.glyph_row
= temp_row
;
11941 display_tool_bar_line (&it
, -1);
11943 clear_glyph_row (temp_row
);
11945 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
11947 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
11949 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
11953 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
11955 doc
: /* Return the number of lines occupied by the tool bar of FRAME.
11956 If FRAME is nil or omitted, use the selected frame. */)
11957 (Lisp_Object frame
)
11959 struct frame
*f
= decode_any_frame (frame
);
11963 if (WINDOWP (f
->tool_bar_window
)
11964 && (w
= XWINDOW (f
->tool_bar_window
),
11965 WINDOW_TOTAL_LINES (w
) > 0))
11967 update_tool_bar (f
, 1);
11968 if (f
->n_tool_bar_items
)
11970 build_desired_tool_bar_string (f
);
11971 nlines
= tool_bar_lines_needed (f
, NULL
);
11975 return make_number (nlines
);
11979 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
11980 height should be changed. */
11983 redisplay_tool_bar (struct frame
*f
)
11987 struct glyph_row
*row
;
11989 #if defined (USE_GTK) || defined (HAVE_NS)
11990 if (FRAME_EXTERNAL_TOOL_BAR (f
))
11991 update_frame_tool_bar (f
);
11995 /* If frame hasn't a tool-bar window or if it is zero-height, don't
11996 do anything. This means you must start with tool-bar-lines
11997 non-zero to get the auto-sizing effect. Or in other words, you
11998 can turn off tool-bars by specifying tool-bar-lines zero. */
11999 if (!WINDOWP (f
->tool_bar_window
)
12000 || (w
= XWINDOW (f
->tool_bar_window
),
12001 WINDOW_TOTAL_LINES (w
) == 0))
12004 /* Set up an iterator for the tool-bar window. */
12005 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
12006 it
.first_visible_x
= 0;
12007 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
12008 row
= it
.glyph_row
;
12010 /* Build a string that represents the contents of the tool-bar. */
12011 build_desired_tool_bar_string (f
);
12012 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
12013 /* FIXME: This should be controlled by a user option. But it
12014 doesn't make sense to have an R2L tool bar if the menu bar cannot
12015 be drawn also R2L, and making the menu bar R2L is tricky due
12016 toolkit-specific code that implements it. If an R2L tool bar is
12017 ever supported, display_tool_bar_line should also be augmented to
12018 call unproduce_glyphs like display_line and display_string
12020 it
.paragraph_embedding
= L2R
;
12022 if (f
->n_tool_bar_rows
== 0)
12026 if ((nlines
= tool_bar_lines_needed (f
, &f
->n_tool_bar_rows
),
12027 nlines
!= WINDOW_TOTAL_LINES (w
)))
12030 int old_height
= WINDOW_TOTAL_LINES (w
);
12032 XSETFRAME (frame
, f
);
12033 Fmodify_frame_parameters (frame
,
12034 Fcons (Fcons (Qtool_bar_lines
,
12035 make_number (nlines
)),
12037 if (WINDOW_TOTAL_LINES (w
) != old_height
)
12039 clear_glyph_matrix (w
->desired_matrix
);
12040 fonts_changed_p
= 1;
12046 /* Display as many lines as needed to display all tool-bar items. */
12048 if (f
->n_tool_bar_rows
> 0)
12050 int border
, rows
, height
, extra
;
12052 if (TYPE_RANGED_INTEGERP (int, Vtool_bar_border
))
12053 border
= XINT (Vtool_bar_border
);
12054 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
12055 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
12056 else if (EQ (Vtool_bar_border
, Qborder_width
))
12057 border
= f
->border_width
;
12063 rows
= f
->n_tool_bar_rows
;
12064 height
= max (1, (it
.last_visible_y
- border
) / rows
);
12065 extra
= it
.last_visible_y
- border
- height
* rows
;
12067 while (it
.current_y
< it
.last_visible_y
)
12070 if (extra
> 0 && rows
-- > 0)
12072 h
= (extra
+ rows
- 1) / rows
;
12075 display_tool_bar_line (&it
, height
+ h
);
12080 while (it
.current_y
< it
.last_visible_y
)
12081 display_tool_bar_line (&it
, 0);
12084 /* It doesn't make much sense to try scrolling in the tool-bar
12085 window, so don't do it. */
12086 w
->desired_matrix
->no_scrolling_p
= 1;
12087 w
->must_be_updated_p
= 1;
12089 if (!NILP (Vauto_resize_tool_bars
))
12091 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
12092 int change_height_p
= 0;
12094 /* If we couldn't display everything, change the tool-bar's
12095 height if there is room for more. */
12096 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
12097 && it
.current_y
< max_tool_bar_height
)
12098 change_height_p
= 1;
12100 row
= it
.glyph_row
- 1;
12102 /* If there are blank lines at the end, except for a partially
12103 visible blank line at the end that is smaller than
12104 FRAME_LINE_HEIGHT, change the tool-bar's height. */
12105 if (!row
->displays_text_p
12106 && row
->height
>= FRAME_LINE_HEIGHT (f
))
12107 change_height_p
= 1;
12109 /* If row displays tool-bar items, but is partially visible,
12110 change the tool-bar's height. */
12111 if (row
->displays_text_p
12112 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
12113 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
12114 change_height_p
= 1;
12116 /* Resize windows as needed by changing the `tool-bar-lines'
12117 frame parameter. */
12118 if (change_height_p
)
12121 int old_height
= WINDOW_TOTAL_LINES (w
);
12123 int nlines
= tool_bar_lines_needed (f
, &nrows
);
12125 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
12126 && !f
->minimize_tool_bar_window_p
)
12127 ? (nlines
> old_height
)
12128 : (nlines
!= old_height
));
12129 f
->minimize_tool_bar_window_p
= 0;
12131 if (change_height_p
)
12133 XSETFRAME (frame
, f
);
12134 Fmodify_frame_parameters (frame
,
12135 Fcons (Fcons (Qtool_bar_lines
,
12136 make_number (nlines
)),
12138 if (WINDOW_TOTAL_LINES (w
) != old_height
)
12140 clear_glyph_matrix (w
->desired_matrix
);
12141 f
->n_tool_bar_rows
= nrows
;
12142 fonts_changed_p
= 1;
12149 f
->minimize_tool_bar_window_p
= 0;
12154 /* Get information about the tool-bar item which is displayed in GLYPH
12155 on frame F. Return in *PROP_IDX the index where tool-bar item
12156 properties start in F->tool_bar_items. Value is zero if
12157 GLYPH doesn't display a tool-bar item. */
12160 tool_bar_item_info (struct frame
*f
, struct glyph
*glyph
, int *prop_idx
)
12166 /* This function can be called asynchronously, which means we must
12167 exclude any possibility that Fget_text_property signals an
12169 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
12170 charpos
= max (0, charpos
);
12172 /* Get the text property `menu-item' at pos. The value of that
12173 property is the start index of this item's properties in
12174 F->tool_bar_items. */
12175 prop
= Fget_text_property (make_number (charpos
),
12176 Qmenu_item
, f
->current_tool_bar_string
);
12177 if (INTEGERP (prop
))
12179 *prop_idx
= XINT (prop
);
12189 /* Get information about the tool-bar item at position X/Y on frame F.
12190 Return in *GLYPH a pointer to the glyph of the tool-bar item in
12191 the current matrix of the tool-bar window of F, or NULL if not
12192 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
12193 item in F->tool_bar_items. Value is
12195 -1 if X/Y is not on a tool-bar item
12196 0 if X/Y is on the same item that was highlighted before.
12200 get_tool_bar_item (struct frame
*f
, int x
, int y
, struct glyph
**glyph
,
12201 int *hpos
, int *vpos
, int *prop_idx
)
12203 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12204 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12207 /* Find the glyph under X/Y. */
12208 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
12209 if (*glyph
== NULL
)
12212 /* Get the start of this tool-bar item's properties in
12213 f->tool_bar_items. */
12214 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
12217 /* Is mouse on the highlighted item? */
12218 if (EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)
12219 && *vpos
>= hlinfo
->mouse_face_beg_row
12220 && *vpos
<= hlinfo
->mouse_face_end_row
12221 && (*vpos
> hlinfo
->mouse_face_beg_row
12222 || *hpos
>= hlinfo
->mouse_face_beg_col
)
12223 && (*vpos
< hlinfo
->mouse_face_end_row
12224 || *hpos
< hlinfo
->mouse_face_end_col
12225 || hlinfo
->mouse_face_past_end
))
12233 Handle mouse button event on the tool-bar of frame F, at
12234 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
12235 0 for button release. MODIFIERS is event modifiers for button
12239 handle_tool_bar_click (struct frame
*f
, int x
, int y
, int down_p
,
12242 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12243 struct window
*w
= XWINDOW (f
->tool_bar_window
);
12244 int hpos
, vpos
, prop_idx
;
12245 struct glyph
*glyph
;
12246 Lisp_Object enabled_p
;
12248 /* If not on the highlighted tool-bar item, return. */
12249 frame_to_window_pixel_xy (w
, &x
, &y
);
12250 if (get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
12253 /* If item is disabled, do nothing. */
12254 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12255 if (NILP (enabled_p
))
12260 /* Show item in pressed state. */
12261 show_mouse_face (hlinfo
, DRAW_IMAGE_SUNKEN
);
12262 last_tool_bar_item
= prop_idx
;
12266 Lisp_Object key
, frame
;
12267 struct input_event event
;
12268 EVENT_INIT (event
);
12270 /* Show item in released state. */
12271 show_mouse_face (hlinfo
, DRAW_IMAGE_RAISED
);
12273 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
12275 XSETFRAME (frame
, f
);
12276 event
.kind
= TOOL_BAR_EVENT
;
12277 event
.frame_or_window
= frame
;
12279 kbd_buffer_store_event (&event
);
12281 event
.kind
= TOOL_BAR_EVENT
;
12282 event
.frame_or_window
= frame
;
12284 event
.modifiers
= modifiers
;
12285 kbd_buffer_store_event (&event
);
12286 last_tool_bar_item
= -1;
12291 /* Possibly highlight a tool-bar item on frame F when mouse moves to
12292 tool-bar window-relative coordinates X/Y. Called from
12293 note_mouse_highlight. */
12296 note_tool_bar_highlight (struct frame
*f
, int x
, int y
)
12298 Lisp_Object window
= f
->tool_bar_window
;
12299 struct window
*w
= XWINDOW (window
);
12300 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
12301 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
12303 struct glyph
*glyph
;
12304 struct glyph_row
*row
;
12306 Lisp_Object enabled_p
;
12308 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
12309 int mouse_down_p
, rc
;
12311 /* Function note_mouse_highlight is called with negative X/Y
12312 values when mouse moves outside of the frame. */
12313 if (x
<= 0 || y
<= 0)
12315 clear_mouse_face (hlinfo
);
12319 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
12322 /* Not on tool-bar item. */
12323 clear_mouse_face (hlinfo
);
12327 /* On same tool-bar item as before. */
12328 goto set_help_echo
;
12330 clear_mouse_face (hlinfo
);
12332 /* Mouse is down, but on different tool-bar item? */
12333 mouse_down_p
= (dpyinfo
->grabbed
12334 && f
== last_mouse_frame
12335 && FRAME_LIVE_P (f
));
12337 && last_tool_bar_item
!= prop_idx
)
12340 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
12342 /* If tool-bar item is not enabled, don't highlight it. */
12343 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
12344 if (!NILP (enabled_p
))
12346 /* Compute the x-position of the glyph. In front and past the
12347 image is a space. We include this in the highlighted area. */
12348 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
12349 for (i
= x
= 0; i
< hpos
; ++i
)
12350 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
12352 /* Record this as the current active region. */
12353 hlinfo
->mouse_face_beg_col
= hpos
;
12354 hlinfo
->mouse_face_beg_row
= vpos
;
12355 hlinfo
->mouse_face_beg_x
= x
;
12356 hlinfo
->mouse_face_beg_y
= row
->y
;
12357 hlinfo
->mouse_face_past_end
= 0;
12359 hlinfo
->mouse_face_end_col
= hpos
+ 1;
12360 hlinfo
->mouse_face_end_row
= vpos
;
12361 hlinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
12362 hlinfo
->mouse_face_end_y
= row
->y
;
12363 hlinfo
->mouse_face_window
= window
;
12364 hlinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
12366 /* Display it as active. */
12367 show_mouse_face (hlinfo
, draw
);
12372 /* Set help_echo_string to a help string to display for this tool-bar item.
12373 XTread_socket does the rest. */
12374 help_echo_object
= help_echo_window
= Qnil
;
12375 help_echo_pos
= -1;
12376 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
12377 if (NILP (help_echo_string
))
12378 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
12381 #endif /* HAVE_WINDOW_SYSTEM */
12385 /************************************************************************
12386 Horizontal scrolling
12387 ************************************************************************/
12389 static int hscroll_window_tree (Lisp_Object
);
12390 static int hscroll_windows (Lisp_Object
);
12392 /* For all leaf windows in the window tree rooted at WINDOW, set their
12393 hscroll value so that PT is (i) visible in the window, and (ii) so
12394 that it is not within a certain margin at the window's left and
12395 right border. Value is non-zero if any window's hscroll has been
12399 hscroll_window_tree (Lisp_Object window
)
12401 int hscrolled_p
= 0;
12402 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
12403 int hscroll_step_abs
= 0;
12404 double hscroll_step_rel
= 0;
12406 if (hscroll_relative_p
)
12408 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
12409 if (hscroll_step_rel
< 0)
12411 hscroll_relative_p
= 0;
12412 hscroll_step_abs
= 0;
12415 else if (TYPE_RANGED_INTEGERP (int, Vhscroll_step
))
12417 hscroll_step_abs
= XINT (Vhscroll_step
);
12418 if (hscroll_step_abs
< 0)
12419 hscroll_step_abs
= 0;
12422 hscroll_step_abs
= 0;
12424 while (WINDOWP (window
))
12426 struct window
*w
= XWINDOW (window
);
12428 if (WINDOWP (w
->hchild
))
12429 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
12430 else if (WINDOWP (w
->vchild
))
12431 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
12432 else if (w
->cursor
.vpos
>= 0)
12435 int text_area_width
;
12436 struct glyph_row
*current_cursor_row
12437 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
12438 struct glyph_row
*desired_cursor_row
12439 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
12440 struct glyph_row
*cursor_row
12441 = (desired_cursor_row
->enabled_p
12442 ? desired_cursor_row
12443 : current_cursor_row
);
12444 int row_r2l_p
= cursor_row
->reversed_p
;
12446 text_area_width
= window_box_width (w
, TEXT_AREA
);
12448 /* Scroll when cursor is inside this scroll margin. */
12449 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
12451 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode
, w
->buffer
))
12452 /* For left-to-right rows, hscroll when cursor is either
12453 (i) inside the right hscroll margin, or (ii) if it is
12454 inside the left margin and the window is already
12458 && w
->cursor
.x
<= h_margin
)
12459 || (cursor_row
->enabled_p
12460 && cursor_row
->truncated_on_right_p
12461 && (w
->cursor
.x
>= text_area_width
- h_margin
))))
12462 /* For right-to-left rows, the logic is similar,
12463 except that rules for scrolling to left and right
12464 are reversed. E.g., if cursor.x <= h_margin, we
12465 need to hscroll "to the right" unconditionally,
12466 and that will scroll the screen to the left so as
12467 to reveal the next portion of the row. */
12469 && ((cursor_row
->enabled_p
12470 /* FIXME: It is confusing to set the
12471 truncated_on_right_p flag when R2L rows
12472 are actually truncated on the left. */
12473 && cursor_row
->truncated_on_right_p
12474 && w
->cursor
.x
<= h_margin
)
12476 && (w
->cursor
.x
>= text_area_width
- h_margin
))))))
12480 struct buffer
*saved_current_buffer
;
12484 /* Find point in a display of infinite width. */
12485 saved_current_buffer
= current_buffer
;
12486 current_buffer
= XBUFFER (w
->buffer
);
12488 if (w
== XWINDOW (selected_window
))
12492 pt
= marker_position (w
->pointm
);
12493 pt
= max (BEGV
, pt
);
12497 /* Move iterator to pt starting at cursor_row->start in
12498 a line with infinite width. */
12499 init_to_row_start (&it
, w
, cursor_row
);
12500 it
.last_visible_x
= INFINITY
;
12501 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
12502 current_buffer
= saved_current_buffer
;
12504 /* Position cursor in window. */
12505 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
12506 hscroll
= max (0, (it
.current_x
12507 - (ITERATOR_AT_END_OF_LINE_P (&it
)
12508 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
12509 : (text_area_width
/ 2))))
12510 / FRAME_COLUMN_WIDTH (it
.f
);
12511 else if ((!row_r2l_p
12512 && w
->cursor
.x
>= text_area_width
- h_margin
)
12513 || (row_r2l_p
&& w
->cursor
.x
<= h_margin
))
12515 if (hscroll_relative_p
)
12516 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
12519 wanted_x
= text_area_width
12520 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12523 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12527 if (hscroll_relative_p
)
12528 wanted_x
= text_area_width
* hscroll_step_rel
12531 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
12534 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
12536 hscroll
= max (hscroll
, w
->min_hscroll
);
12538 /* Don't prevent redisplay optimizations if hscroll
12539 hasn't changed, as it will unnecessarily slow down
12541 if (w
->hscroll
!= hscroll
)
12543 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
12544 w
->hscroll
= hscroll
;
12553 /* Value is non-zero if hscroll of any leaf window has been changed. */
12554 return hscrolled_p
;
12558 /* Set hscroll so that cursor is visible and not inside horizontal
12559 scroll margins for all windows in the tree rooted at WINDOW. See
12560 also hscroll_window_tree above. Value is non-zero if any window's
12561 hscroll has been changed. If it has, desired matrices on the frame
12562 of WINDOW are cleared. */
12565 hscroll_windows (Lisp_Object window
)
12567 int hscrolled_p
= hscroll_window_tree (window
);
12569 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
12570 return hscrolled_p
;
12575 /************************************************************************
12577 ************************************************************************/
12579 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
12580 to a non-zero value. This is sometimes handy to have in a debugger
12585 /* First and last unchanged row for try_window_id. */
12587 static int debug_first_unchanged_at_end_vpos
;
12588 static int debug_last_unchanged_at_beg_vpos
;
12590 /* Delta vpos and y. */
12592 static int debug_dvpos
, debug_dy
;
12594 /* Delta in characters and bytes for try_window_id. */
12596 static ptrdiff_t debug_delta
, debug_delta_bytes
;
12598 /* Values of window_end_pos and window_end_vpos at the end of
12601 static ptrdiff_t debug_end_vpos
;
12603 /* Append a string to W->desired_matrix->method. FMT is a printf
12604 format string. If trace_redisplay_p is non-zero also printf the
12605 resulting string to stderr. */
12607 static void debug_method_add (struct window
*, char const *, ...)
12608 ATTRIBUTE_FORMAT_PRINTF (2, 3);
12611 debug_method_add (struct window
*w
, char const *fmt
, ...)
12613 char *method
= w
->desired_matrix
->method
;
12614 int len
= strlen (method
);
12615 int size
= sizeof w
->desired_matrix
->method
;
12616 int remaining
= size
- len
- 1;
12619 if (len
&& remaining
)
12622 --remaining
, ++len
;
12625 va_start (ap
, fmt
);
12626 vsnprintf (method
+ len
, remaining
+ 1, fmt
, ap
);
12629 if (trace_redisplay_p
)
12630 fprintf (stderr
, "%p (%s): %s\n",
12632 ((BUFFERP (w
->buffer
)
12633 && STRINGP (BVAR (XBUFFER (w
->buffer
), name
)))
12634 ? SSDATA (BVAR (XBUFFER (w
->buffer
), name
))
12639 #endif /* GLYPH_DEBUG */
12642 /* Value is non-zero if all changes in window W, which displays
12643 current_buffer, are in the text between START and END. START is a
12644 buffer position, END is given as a distance from Z. Used in
12645 redisplay_internal for display optimization. */
12648 text_outside_line_unchanged_p (struct window
*w
,
12649 ptrdiff_t start
, ptrdiff_t end
)
12651 int unchanged_p
= 1;
12653 /* If text or overlays have changed, see where. */
12654 if (window_outdated (w
))
12656 /* Gap in the line? */
12657 if (GPT
< start
|| Z
- GPT
< end
)
12660 /* Changes start in front of the line, or end after it? */
12662 && (BEG_UNCHANGED
< start
- 1
12663 || END_UNCHANGED
< end
))
12666 /* If selective display, can't optimize if changes start at the
12667 beginning of the line. */
12669 && INTEGERP (BVAR (current_buffer
, selective_display
))
12670 && XINT (BVAR (current_buffer
, selective_display
)) > 0
12671 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
12674 /* If there are overlays at the start or end of the line, these
12675 may have overlay strings with newlines in them. A change at
12676 START, for instance, may actually concern the display of such
12677 overlay strings as well, and they are displayed on different
12678 lines. So, quickly rule out this case. (For the future, it
12679 might be desirable to implement something more telling than
12680 just BEG/END_UNCHANGED.) */
12683 if (BEG
+ BEG_UNCHANGED
== start
12684 && overlay_touches_p (start
))
12686 if (END_UNCHANGED
== end
12687 && overlay_touches_p (Z
- end
))
12691 /* Under bidi reordering, adding or deleting a character in the
12692 beginning of a paragraph, before the first strong directional
12693 character, can change the base direction of the paragraph (unless
12694 the buffer specifies a fixed paragraph direction), which will
12695 require to redisplay the whole paragraph. It might be worthwhile
12696 to find the paragraph limits and widen the range of redisplayed
12697 lines to that, but for now just give up this optimization. */
12698 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
12699 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
12703 return unchanged_p
;
12707 /* Do a frame update, taking possible shortcuts into account. This is
12708 the main external entry point for redisplay.
12710 If the last redisplay displayed an echo area message and that message
12711 is no longer requested, we clear the echo area or bring back the
12712 mini-buffer if that is in use. */
12717 redisplay_internal ();
12722 overlay_arrow_string_or_property (Lisp_Object var
)
12726 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
12729 return Voverlay_arrow_string
;
12732 /* Return 1 if there are any overlay-arrows in current_buffer. */
12734 overlay_arrow_in_current_buffer_p (void)
12738 for (vlist
= Voverlay_arrow_variable_list
;
12740 vlist
= XCDR (vlist
))
12742 Lisp_Object var
= XCAR (vlist
);
12745 if (!SYMBOLP (var
))
12747 val
= find_symbol_value (var
);
12749 && current_buffer
== XMARKER (val
)->buffer
)
12756 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
12760 overlay_arrows_changed_p (void)
12764 for (vlist
= Voverlay_arrow_variable_list
;
12766 vlist
= XCDR (vlist
))
12768 Lisp_Object var
= XCAR (vlist
);
12769 Lisp_Object val
, pstr
;
12771 if (!SYMBOLP (var
))
12773 val
= find_symbol_value (var
);
12774 if (!MARKERP (val
))
12776 if (! EQ (COERCE_MARKER (val
),
12777 Fget (var
, Qlast_arrow_position
))
12778 || ! (pstr
= overlay_arrow_string_or_property (var
),
12779 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
12785 /* Mark overlay arrows to be updated on next redisplay. */
12788 update_overlay_arrows (int up_to_date
)
12792 for (vlist
= Voverlay_arrow_variable_list
;
12794 vlist
= XCDR (vlist
))
12796 Lisp_Object var
= XCAR (vlist
);
12798 if (!SYMBOLP (var
))
12801 if (up_to_date
> 0)
12803 Lisp_Object val
= find_symbol_value (var
);
12804 Fput (var
, Qlast_arrow_position
,
12805 COERCE_MARKER (val
));
12806 Fput (var
, Qlast_arrow_string
,
12807 overlay_arrow_string_or_property (var
));
12809 else if (up_to_date
< 0
12810 || !NILP (Fget (var
, Qlast_arrow_position
)))
12812 Fput (var
, Qlast_arrow_position
, Qt
);
12813 Fput (var
, Qlast_arrow_string
, Qt
);
12819 /* Return overlay arrow string to display at row.
12820 Return integer (bitmap number) for arrow bitmap in left fringe.
12821 Return nil if no overlay arrow. */
12824 overlay_arrow_at_row (struct it
*it
, struct glyph_row
*row
)
12828 for (vlist
= Voverlay_arrow_variable_list
;
12830 vlist
= XCDR (vlist
))
12832 Lisp_Object var
= XCAR (vlist
);
12835 if (!SYMBOLP (var
))
12838 val
= find_symbol_value (var
);
12841 && current_buffer
== XMARKER (val
)->buffer
12842 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
12844 if (FRAME_WINDOW_P (it
->f
)
12845 /* FIXME: if ROW->reversed_p is set, this should test
12846 the right fringe, not the left one. */
12847 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
12849 #ifdef HAVE_WINDOW_SYSTEM
12850 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
12853 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
12854 return make_number (fringe_bitmap
);
12857 return make_number (-1); /* Use default arrow bitmap. */
12859 return overlay_arrow_string_or_property (var
);
12866 /* Return 1 if point moved out of or into a composition. Otherwise
12867 return 0. PREV_BUF and PREV_PT are the last point buffer and
12868 position. BUF and PT are the current point buffer and position. */
12871 check_point_in_composition (struct buffer
*prev_buf
, ptrdiff_t prev_pt
,
12872 struct buffer
*buf
, ptrdiff_t pt
)
12874 ptrdiff_t start
, end
;
12876 Lisp_Object buffer
;
12878 XSETBUFFER (buffer
, buf
);
12879 /* Check a composition at the last point if point moved within the
12881 if (prev_buf
== buf
)
12884 /* Point didn't move. */
12887 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
12888 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
12889 && COMPOSITION_VALID_P (start
, end
, prop
)
12890 && start
< prev_pt
&& end
> prev_pt
)
12891 /* The last point was within the composition. Return 1 iff
12892 point moved out of the composition. */
12893 return (pt
<= start
|| pt
>= end
);
12896 /* Check a composition at the current point. */
12897 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
12898 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
12899 && COMPOSITION_VALID_P (start
, end
, prop
)
12900 && start
< pt
&& end
> pt
);
12904 /* Reconsider the setting of B->clip_changed which is displayed
12908 reconsider_clip_changes (struct window
*w
, struct buffer
*b
)
12910 if (b
->clip_changed
12911 && !NILP (w
->window_end_valid
)
12912 && w
->current_matrix
->buffer
== b
12913 && w
->current_matrix
->zv
== BUF_ZV (b
)
12914 && w
->current_matrix
->begv
== BUF_BEGV (b
))
12915 b
->clip_changed
= 0;
12917 /* If display wasn't paused, and W is not a tool bar window, see if
12918 point has been moved into or out of a composition. In that case,
12919 we set b->clip_changed to 1 to force updating the screen. If
12920 b->clip_changed has already been set to 1, we can skip this
12922 if (!b
->clip_changed
12923 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
12927 if (w
== XWINDOW (selected_window
))
12930 pt
= marker_position (w
->pointm
);
12932 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
12933 || pt
!= w
->last_point
)
12934 && check_point_in_composition (w
->current_matrix
->buffer
,
12936 XBUFFER (w
->buffer
), pt
))
12937 b
->clip_changed
= 1;
12942 /* Select FRAME to forward the values of frame-local variables into C
12943 variables so that the redisplay routines can access those values
12947 select_frame_for_redisplay (Lisp_Object frame
)
12949 Lisp_Object tail
, tem
;
12950 Lisp_Object old
= selected_frame
;
12951 struct Lisp_Symbol
*sym
;
12953 eassert (FRAMEP (frame
) && FRAME_LIVE_P (XFRAME (frame
)));
12955 selected_frame
= frame
;
12958 for (tail
= XFRAME (frame
)->param_alist
;
12959 CONSP (tail
); tail
= XCDR (tail
))
12960 if (CONSP (XCAR (tail
))
12961 && (tem
= XCAR (XCAR (tail
)),
12963 && (sym
= indirect_variable (XSYMBOL (tem
)),
12964 sym
->redirect
== SYMBOL_LOCALIZED
)
12965 && sym
->val
.blv
->frame_local
)
12966 /* Use find_symbol_value rather than Fsymbol_value
12967 to avoid an error if it is void. */
12968 find_symbol_value (tem
);
12969 } while (!EQ (frame
, old
) && (frame
= old
, 1));
12972 /* Make sure that previously selected OLD_FRAME is selected unless it has been
12973 deleted (by an X connection failure during redisplay, for example). */
12976 ensure_selected_frame (Lisp_Object old_frame
)
12978 if (!EQ (old_frame
, selected_frame
) && FRAME_LIVE_P (XFRAME (old_frame
)))
12979 select_frame_for_redisplay (old_frame
);
12982 #define STOP_POLLING \
12983 do { if (! polling_stopped_here) stop_polling (); \
12984 polling_stopped_here = 1; } while (0)
12986 #define RESUME_POLLING \
12987 do { if (polling_stopped_here) start_polling (); \
12988 polling_stopped_here = 0; } while (0)
12991 /* Perhaps in the future avoid recentering windows if it
12992 is not necessary; currently that causes some problems. */
12995 redisplay_internal (void)
12997 struct window
*w
= XWINDOW (selected_window
);
13001 int must_finish
= 0;
13002 struct text_pos tlbufpos
, tlendpos
;
13003 int number_of_visible_frames
;
13004 ptrdiff_t count
, count1
;
13006 int polling_stopped_here
= 0;
13007 Lisp_Object tail
, frame
, old_frame
= selected_frame
;
13008 struct backtrace backtrace
;
13010 /* Non-zero means redisplay has to consider all windows on all
13011 frames. Zero means, only selected_window is considered. */
13012 int consider_all_windows_p
;
13014 /* Non-zero means redisplay has to redisplay the miniwindow. */
13015 int update_miniwindow_p
= 0;
13017 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
13019 /* No redisplay if running in batch mode or frame is not yet fully
13020 initialized, or redisplay is explicitly turned off by setting
13021 Vinhibit_redisplay. */
13022 if (FRAME_INITIAL_P (SELECTED_FRAME ())
13023 || !NILP (Vinhibit_redisplay
))
13026 /* Don't examine these until after testing Vinhibit_redisplay.
13027 When Emacs is shutting down, perhaps because its connection to
13028 X has dropped, we should not look at them at all. */
13029 fr
= XFRAME (w
->frame
);
13030 sf
= SELECTED_FRAME ();
13032 if (!fr
->glyphs_initialized_p
)
13035 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
13036 if (popup_activated ())
13040 /* I don't think this happens but let's be paranoid. */
13041 if (redisplaying_p
)
13044 /* Record a function that clears redisplaying_p
13045 when we leave this function. */
13046 count
= SPECPDL_INDEX ();
13047 record_unwind_protect (unwind_redisplay
, selected_frame
);
13048 redisplaying_p
= 1;
13049 specbind (Qinhibit_free_realized_faces
, Qnil
);
13051 /* Record this function, so it appears on the profiler's backtraces. */
13052 backtrace
.next
= backtrace_list
;
13053 backtrace
.function
= Qredisplay_internal
;
13054 backtrace
.args
= &Qnil
;
13055 backtrace
.nargs
= 0;
13056 backtrace
.debug_on_exit
= 0;
13057 backtrace_list
= &backtrace
;
13059 FOR_EACH_FRAME (tail
, frame
)
13060 XFRAME (frame
)->already_hscrolled_p
= 0;
13063 /* Remember the currently selected window. */
13066 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
13067 selected_frame and selected_window to be temporarily out-of-sync so
13068 when we come back here via `goto retry', we need to resync because we
13069 may need to run Elisp code (via prepare_menu_bars). */
13070 ensure_selected_frame (old_frame
);
13073 reconsider_clip_changes (w
, current_buffer
);
13074 last_escape_glyph_frame
= NULL
;
13075 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
13076 last_glyphless_glyph_frame
= NULL
;
13077 last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
13079 /* If new fonts have been loaded that make a glyph matrix adjustment
13080 necessary, do it. */
13081 if (fonts_changed_p
)
13083 adjust_glyphs (NULL
);
13084 ++windows_or_buffers_changed
;
13085 fonts_changed_p
= 0;
13088 /* If face_change_count is non-zero, init_iterator will free all
13089 realized faces, which includes the faces referenced from current
13090 matrices. So, we can't reuse current matrices in this case. */
13091 if (face_change_count
)
13092 ++windows_or_buffers_changed
;
13094 if ((FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
13095 && FRAME_TTY (sf
)->previous_frame
!= sf
)
13097 /* Since frames on a single ASCII terminal share the same
13098 display area, displaying a different frame means redisplay
13099 the whole thing. */
13100 windows_or_buffers_changed
++;
13101 SET_FRAME_GARBAGED (sf
);
13103 set_tty_color_mode (FRAME_TTY (sf
), sf
);
13105 FRAME_TTY (sf
)->previous_frame
= sf
;
13108 /* Set the visible flags for all frames. Do this before checking for
13109 resized or garbaged frames; they want to know if their frames are
13110 visible. See the comment in frame.h for FRAME_SAMPLE_VISIBILITY. */
13111 number_of_visible_frames
= 0;
13113 FOR_EACH_FRAME (tail
, frame
)
13115 struct frame
*f
= XFRAME (frame
);
13117 FRAME_SAMPLE_VISIBILITY (f
);
13118 if (FRAME_VISIBLE_P (f
))
13119 ++number_of_visible_frames
;
13120 clear_desired_matrices (f
);
13123 /* Notice any pending interrupt request to change frame size. */
13124 do_pending_window_change (1);
13126 /* do_pending_window_change could change the selected_window due to
13127 frame resizing which makes the selected window too small. */
13128 if (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
)
13131 reconsider_clip_changes (w
, current_buffer
);
13134 /* Clear frames marked as garbaged. */
13135 clear_garbaged_frames ();
13137 /* Build menubar and tool-bar items. */
13138 if (NILP (Vmemory_full
))
13139 prepare_menu_bars ();
13141 if (windows_or_buffers_changed
)
13142 update_mode_lines
++;
13144 /* Detect case that we need to write or remove a star in the mode line. */
13145 if ((SAVE_MODIFF
< MODIFF
) != w
->last_had_star
)
13147 w
->update_mode_line
= 1;
13148 if (buffer_shared_and_changed ())
13149 update_mode_lines
++;
13152 /* Avoid invocation of point motion hooks by `current_column' below. */
13153 count1
= SPECPDL_INDEX ();
13154 specbind (Qinhibit_point_motion_hooks
, Qt
);
13156 if (mode_line_update_needed (w
))
13157 w
->update_mode_line
= 1;
13159 unbind_to (count1
, Qnil
);
13161 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
13163 consider_all_windows_p
= (update_mode_lines
13164 || buffer_shared_and_changed ()
13165 || cursor_type_changed
);
13167 /* If specs for an arrow have changed, do thorough redisplay
13168 to ensure we remove any arrow that should no longer exist. */
13169 if (overlay_arrows_changed_p ())
13170 consider_all_windows_p
= windows_or_buffers_changed
= 1;
13172 /* Normally the message* functions will have already displayed and
13173 updated the echo area, but the frame may have been trashed, or
13174 the update may have been preempted, so display the echo area
13175 again here. Checking message_cleared_p captures the case that
13176 the echo area should be cleared. */
13177 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
13178 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
13179 || (message_cleared_p
13180 && minibuf_level
== 0
13181 /* If the mini-window is currently selected, this means the
13182 echo-area doesn't show through. */
13183 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
13185 int window_height_changed_p
= echo_area_display (0);
13187 if (message_cleared_p
)
13188 update_miniwindow_p
= 1;
13192 /* If we don't display the current message, don't clear the
13193 message_cleared_p flag, because, if we did, we wouldn't clear
13194 the echo area in the next redisplay which doesn't preserve
13196 if (!display_last_displayed_message_p
)
13197 message_cleared_p
= 0;
13199 if (fonts_changed_p
)
13201 else if (window_height_changed_p
)
13203 consider_all_windows_p
= 1;
13204 ++update_mode_lines
;
13205 ++windows_or_buffers_changed
;
13207 /* If window configuration was changed, frames may have been
13208 marked garbaged. Clear them or we will experience
13209 surprises wrt scrolling. */
13210 clear_garbaged_frames ();
13213 else if (EQ (selected_window
, minibuf_window
)
13214 && (current_buffer
->clip_changed
|| window_outdated (w
))
13215 && resize_mini_window (w
, 0))
13217 /* Resized active mini-window to fit the size of what it is
13218 showing if its contents might have changed. */
13220 /* FIXME: this causes all frames to be updated, which seems unnecessary
13221 since only the current frame needs to be considered. This function
13222 needs to be rewritten with two variables, consider_all_windows and
13223 consider_all_frames. */
13224 consider_all_windows_p
= 1;
13225 ++windows_or_buffers_changed
;
13226 ++update_mode_lines
;
13228 /* If window configuration was changed, frames may have been
13229 marked garbaged. Clear them or we will experience
13230 surprises wrt scrolling. */
13231 clear_garbaged_frames ();
13235 /* If showing the region, and mark has changed, we must redisplay
13236 the whole window. The assignment to this_line_start_pos prevents
13237 the optimization directly below this if-statement. */
13238 if (((!NILP (Vtransient_mark_mode
)
13239 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
13240 != !NILP (w
->region_showing
))
13241 || (!NILP (w
->region_showing
)
13242 && !EQ (w
->region_showing
,
13243 Fmarker_position (BVAR (XBUFFER (w
->buffer
), mark
)))))
13244 CHARPOS (this_line_start_pos
) = 0;
13246 /* Optimize the case that only the line containing the cursor in the
13247 selected window has changed. Variables starting with this_ are
13248 set in display_line and record information about the line
13249 containing the cursor. */
13250 tlbufpos
= this_line_start_pos
;
13251 tlendpos
= this_line_end_pos
;
13252 if (!consider_all_windows_p
13253 && CHARPOS (tlbufpos
) > 0
13254 && !w
->update_mode_line
13255 && !current_buffer
->clip_changed
13256 && !current_buffer
->prevent_redisplay_optimizations_p
13257 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
13258 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
13259 /* Make sure recorded data applies to current buffer, etc. */
13260 && this_line_buffer
== current_buffer
13261 && current_buffer
== XBUFFER (w
->buffer
)
13263 && !w
->optional_new_start
13264 /* Point must be on the line that we have info recorded about. */
13265 && PT
>= CHARPOS (tlbufpos
)
13266 && PT
<= Z
- CHARPOS (tlendpos
)
13267 /* All text outside that line, including its final newline,
13268 must be unchanged. */
13269 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
13270 CHARPOS (tlendpos
)))
13272 if (CHARPOS (tlbufpos
) > BEGV
13273 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
13274 && (CHARPOS (tlbufpos
) == ZV
13275 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
13276 /* Former continuation line has disappeared by becoming empty. */
13278 else if (window_outdated (w
) || MINI_WINDOW_P (w
))
13280 /* We have to handle the case of continuation around a
13281 wide-column character (see the comment in indent.c around
13284 For instance, in the following case:
13286 -------- Insert --------
13287 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
13288 J_I_ ==> J_I_ `^^' are cursors.
13292 As we have to redraw the line above, we cannot use this
13296 int line_height_before
= this_line_pixel_height
;
13298 /* Note that start_display will handle the case that the
13299 line starting at tlbufpos is a continuation line. */
13300 start_display (&it
, w
, tlbufpos
);
13302 /* Implementation note: It this still necessary? */
13303 if (it
.current_x
!= this_line_start_x
)
13306 TRACE ((stderr
, "trying display optimization 1\n"));
13307 w
->cursor
.vpos
= -1;
13308 overlay_arrow_seen
= 0;
13309 it
.vpos
= this_line_vpos
;
13310 it
.current_y
= this_line_y
;
13311 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
13312 display_line (&it
);
13314 /* If line contains point, is not continued,
13315 and ends at same distance from eob as before, we win. */
13316 if (w
->cursor
.vpos
>= 0
13317 /* Line is not continued, otherwise this_line_start_pos
13318 would have been set to 0 in display_line. */
13319 && CHARPOS (this_line_start_pos
)
13320 /* Line ends as before. */
13321 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
13322 /* Line has same height as before. Otherwise other lines
13323 would have to be shifted up or down. */
13324 && this_line_pixel_height
== line_height_before
)
13326 /* If this is not the window's last line, we must adjust
13327 the charstarts of the lines below. */
13328 if (it
.current_y
< it
.last_visible_y
)
13330 struct glyph_row
*row
13331 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
13332 ptrdiff_t delta
, delta_bytes
;
13334 /* We used to distinguish between two cases here,
13335 conditioned by Z - CHARPOS (tlendpos) == ZV, for
13336 when the line ends in a newline or the end of the
13337 buffer's accessible portion. But both cases did
13338 the same, so they were collapsed. */
13340 - CHARPOS (tlendpos
)
13341 - MATRIX_ROW_START_CHARPOS (row
));
13342 delta_bytes
= (Z_BYTE
13343 - BYTEPOS (tlendpos
)
13344 - MATRIX_ROW_START_BYTEPOS (row
));
13346 increment_matrix_positions (w
->current_matrix
,
13347 this_line_vpos
+ 1,
13348 w
->current_matrix
->nrows
,
13349 delta
, delta_bytes
);
13352 /* If this row displays text now but previously didn't,
13353 or vice versa, w->window_end_vpos may have to be
13355 if ((it
.glyph_row
- 1)->displays_text_p
)
13357 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
13358 wset_window_end_vpos (w
, make_number (this_line_vpos
));
13360 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
13361 && this_line_vpos
> 0)
13362 wset_window_end_vpos (w
, make_number (this_line_vpos
- 1));
13363 wset_window_end_valid (w
, Qnil
);
13365 /* Update hint: No need to try to scroll in update_window. */
13366 w
->desired_matrix
->no_scrolling_p
= 1;
13369 *w
->desired_matrix
->method
= 0;
13370 debug_method_add (w
, "optimization 1");
13372 #ifdef HAVE_WINDOW_SYSTEM
13373 update_window_fringes (w
, 0);
13380 else if (/* Cursor position hasn't changed. */
13381 PT
== w
->last_point
13382 /* Make sure the cursor was last displayed
13383 in this window. Otherwise we have to reposition it. */
13384 && 0 <= w
->cursor
.vpos
13385 && WINDOW_TOTAL_LINES (w
) > w
->cursor
.vpos
)
13389 do_pending_window_change (1);
13390 /* If selected_window changed, redisplay again. */
13391 if (WINDOWP (selected_window
)
13392 && (w
= XWINDOW (selected_window
)) != sw
)
13395 /* We used to always goto end_of_redisplay here, but this
13396 isn't enough if we have a blinking cursor. */
13397 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
13398 goto end_of_redisplay
;
13402 /* If highlighting the region, or if the cursor is in the echo area,
13403 then we can't just move the cursor. */
13404 else if (! (!NILP (Vtransient_mark_mode
)
13405 && !NILP (BVAR (current_buffer
, mark_active
)))
13406 && (EQ (selected_window
,
13407 BVAR (current_buffer
, last_selected_window
))
13408 || highlight_nonselected_windows
)
13409 && NILP (w
->region_showing
)
13410 && NILP (Vshow_trailing_whitespace
)
13411 && !cursor_in_echo_area
)
13414 struct glyph_row
*row
;
13416 /* Skip from tlbufpos to PT and see where it is. Note that
13417 PT may be in invisible text. If so, we will end at the
13418 next visible position. */
13419 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
13420 NULL
, DEFAULT_FACE_ID
);
13421 it
.current_x
= this_line_start_x
;
13422 it
.current_y
= this_line_y
;
13423 it
.vpos
= this_line_vpos
;
13425 /* The call to move_it_to stops in front of PT, but
13426 moves over before-strings. */
13427 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
13429 if (it
.vpos
== this_line_vpos
13430 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
13433 eassert (this_line_vpos
== it
.vpos
);
13434 eassert (this_line_y
== it
.current_y
);
13435 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
13437 *w
->desired_matrix
->method
= 0;
13438 debug_method_add (w
, "optimization 3");
13447 /* Text changed drastically or point moved off of line. */
13448 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
13451 CHARPOS (this_line_start_pos
) = 0;
13452 consider_all_windows_p
|= buffer_shared_and_changed ();
13453 ++clear_face_cache_count
;
13454 #ifdef HAVE_WINDOW_SYSTEM
13455 ++clear_image_cache_count
;
13458 /* Build desired matrices, and update the display. If
13459 consider_all_windows_p is non-zero, do it for all windows on all
13460 frames. Otherwise do it for selected_window, only. */
13462 if (consider_all_windows_p
)
13464 FOR_EACH_FRAME (tail
, frame
)
13465 XFRAME (frame
)->updated_p
= 0;
13467 FOR_EACH_FRAME (tail
, frame
)
13469 struct frame
*f
= XFRAME (frame
);
13471 /* We don't have to do anything for unselected terminal
13473 if ((FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
13474 && !EQ (FRAME_TTY (f
)->top_frame
, frame
))
13477 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
13479 if (! EQ (frame
, selected_frame
))
13480 /* Select the frame, for the sake of frame-local
13482 select_frame_for_redisplay (frame
);
13484 /* Mark all the scroll bars to be removed; we'll redeem
13485 the ones we want when we redisplay their windows. */
13486 if (FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
13487 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
13489 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13490 redisplay_windows (FRAME_ROOT_WINDOW (f
));
13492 /* The X error handler may have deleted that frame. */
13493 if (!FRAME_LIVE_P (f
))
13496 /* Any scroll bars which redisplay_windows should have
13497 nuked should now go away. */
13498 if (FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
13499 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
13501 /* If fonts changed, display again. */
13502 /* ??? rms: I suspect it is a mistake to jump all the way
13503 back to retry here. It should just retry this frame. */
13504 if (fonts_changed_p
)
13507 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
13509 /* See if we have to hscroll. */
13510 if (!f
->already_hscrolled_p
)
13512 f
->already_hscrolled_p
= 1;
13513 if (hscroll_windows (f
->root_window
))
13517 /* Prevent various kinds of signals during display
13518 update. stdio is not robust about handling
13519 signals, which can cause an apparent I/O
13521 if (interrupt_input
)
13522 unrequest_sigio ();
13525 /* Update the display. */
13526 set_window_update_flags (XWINDOW (f
->root_window
), 1);
13527 pending
|= update_frame (f
, 0, 0);
13533 /* We played a bit fast-and-loose above and allowed selected_frame
13534 and selected_window to be temporarily out-of-sync but let's make
13535 sure this stays contained. */
13536 ensure_selected_frame (old_frame
);
13537 eassert (EQ (XFRAME (selected_frame
)->selected_window
, selected_window
));
13541 /* Do the mark_window_display_accurate after all windows have
13542 been redisplayed because this call resets flags in buffers
13543 which are needed for proper redisplay. */
13544 FOR_EACH_FRAME (tail
, frame
)
13546 struct frame
*f
= XFRAME (frame
);
13549 mark_window_display_accurate (f
->root_window
, 1);
13550 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
13551 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
13556 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13558 Lisp_Object mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13559 struct frame
*mini_frame
;
13561 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
13562 /* Use list_of_error, not Qerror, so that
13563 we catch only errors and don't run the debugger. */
13564 internal_condition_case_1 (redisplay_window_1
, selected_window
,
13566 redisplay_window_error
);
13567 if (update_miniwindow_p
)
13568 internal_condition_case_1 (redisplay_window_1
, mini_window
,
13570 redisplay_window_error
);
13572 /* Compare desired and current matrices, perform output. */
13575 /* If fonts changed, display again. */
13576 if (fonts_changed_p
)
13579 /* Prevent various kinds of signals during display update.
13580 stdio is not robust about handling signals,
13581 which can cause an apparent I/O error. */
13582 if (interrupt_input
)
13583 unrequest_sigio ();
13586 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
13588 if (hscroll_windows (selected_window
))
13591 XWINDOW (selected_window
)->must_be_updated_p
= 1;
13592 pending
= update_frame (sf
, 0, 0);
13595 /* We may have called echo_area_display at the top of this
13596 function. If the echo area is on another frame, that may
13597 have put text on a frame other than the selected one, so the
13598 above call to update_frame would not have caught it. Catch
13600 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
13601 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
13603 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
13605 XWINDOW (mini_window
)->must_be_updated_p
= 1;
13606 pending
|= update_frame (mini_frame
, 0, 0);
13607 if (!pending
&& hscroll_windows (mini_window
))
13612 /* If display was paused because of pending input, make sure we do a
13613 thorough update the next time. */
13616 /* Prevent the optimization at the beginning of
13617 redisplay_internal that tries a single-line update of the
13618 line containing the cursor in the selected window. */
13619 CHARPOS (this_line_start_pos
) = 0;
13621 /* Let the overlay arrow be updated the next time. */
13622 update_overlay_arrows (0);
13624 /* If we pause after scrolling, some rows in the current
13625 matrices of some windows are not valid. */
13626 if (!WINDOW_FULL_WIDTH_P (w
)
13627 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
13628 update_mode_lines
= 1;
13632 if (!consider_all_windows_p
)
13634 /* This has already been done above if
13635 consider_all_windows_p is set. */
13636 mark_window_display_accurate_1 (w
, 1);
13638 /* Say overlay arrows are up to date. */
13639 update_overlay_arrows (1);
13641 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
13642 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
13645 update_mode_lines
= 0;
13646 windows_or_buffers_changed
= 0;
13647 cursor_type_changed
= 0;
13650 /* Start SIGIO interrupts coming again. Having them off during the
13651 code above makes it less likely one will discard output, but not
13652 impossible, since there might be stuff in the system buffer here.
13653 But it is much hairier to try to do anything about that. */
13654 if (interrupt_input
)
13658 /* If a frame has become visible which was not before, redisplay
13659 again, so that we display it. Expose events for such a frame
13660 (which it gets when becoming visible) don't call the parts of
13661 redisplay constructing glyphs, so simply exposing a frame won't
13662 display anything in this case. So, we have to display these
13663 frames here explicitly. */
13668 FOR_EACH_FRAME (tail
, frame
)
13670 int this_is_visible
= 0;
13672 if (XFRAME (frame
)->visible
)
13673 this_is_visible
= 1;
13674 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
13675 if (XFRAME (frame
)->visible
)
13676 this_is_visible
= 1;
13678 if (this_is_visible
)
13682 if (new_count
!= number_of_visible_frames
)
13683 windows_or_buffers_changed
++;
13686 /* Change frame size now if a change is pending. */
13687 do_pending_window_change (1);
13689 /* If we just did a pending size change, or have additional
13690 visible frames, or selected_window changed, redisplay again. */
13691 if ((windows_or_buffers_changed
&& !pending
)
13692 || (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
))
13695 /* Clear the face and image caches.
13697 We used to do this only if consider_all_windows_p. But the cache
13698 needs to be cleared if a timer creates images in the current
13699 buffer (e.g. the test case in Bug#6230). */
13701 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
13703 clear_face_cache (0);
13704 clear_face_cache_count
= 0;
13707 #ifdef HAVE_WINDOW_SYSTEM
13708 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
13710 clear_image_caches (Qnil
);
13711 clear_image_cache_count
= 0;
13713 #endif /* HAVE_WINDOW_SYSTEM */
13716 backtrace_list
= backtrace
.next
;
13717 unbind_to (count
, Qnil
);
13722 /* Redisplay, but leave alone any recent echo area message unless
13723 another message has been requested in its place.
13725 This is useful in situations where you need to redisplay but no
13726 user action has occurred, making it inappropriate for the message
13727 area to be cleared. See tracking_off and
13728 wait_reading_process_output for examples of these situations.
13730 FROM_WHERE is an integer saying from where this function was
13731 called. This is useful for debugging. */
13734 redisplay_preserve_echo_area (int from_where
)
13736 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
13738 if (!NILP (echo_area_buffer
[1]))
13740 /* We have a previously displayed message, but no current
13741 message. Redisplay the previous message. */
13742 display_last_displayed_message_p
= 1;
13743 redisplay_internal ();
13744 display_last_displayed_message_p
= 0;
13747 redisplay_internal ();
13749 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
13750 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
13751 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL
);
13755 /* Function registered with record_unwind_protect in redisplay_internal.
13756 Clear redisplaying_p. Also select the previously selected frame. */
13759 unwind_redisplay (Lisp_Object old_frame
)
13761 redisplaying_p
= 0;
13762 ensure_selected_frame (old_frame
);
13767 /* Mark the display of window W as accurate or inaccurate. If
13768 ACCURATE_P is non-zero mark display of W as accurate. If
13769 ACCURATE_P is zero, arrange for W to be redisplayed the next time
13770 redisplay_internal is called. */
13773 mark_window_display_accurate_1 (struct window
*w
, int accurate_p
)
13775 if (BUFFERP (w
->buffer
))
13777 struct buffer
*b
= XBUFFER (w
->buffer
);
13779 w
->last_modified
= accurate_p
? BUF_MODIFF(b
) : 0;
13780 w
->last_overlay_modified
= accurate_p
? BUF_OVERLAY_MODIFF(b
) : 0;
13782 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
);
13786 b
->clip_changed
= 0;
13787 b
->prevent_redisplay_optimizations_p
= 0;
13789 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
13790 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
13791 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
13792 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
13794 w
->current_matrix
->buffer
= b
;
13795 w
->current_matrix
->begv
= BUF_BEGV (b
);
13796 w
->current_matrix
->zv
= BUF_ZV (b
);
13798 w
->last_cursor
= w
->cursor
;
13799 w
->last_cursor_off_p
= w
->cursor_off_p
;
13801 if (w
== XWINDOW (selected_window
))
13802 w
->last_point
= BUF_PT (b
);
13804 w
->last_point
= XMARKER (w
->pointm
)->charpos
;
13810 wset_window_end_valid (w
, w
->buffer
);
13811 w
->update_mode_line
= 0;
13816 /* Mark the display of windows in the window tree rooted at WINDOW as
13817 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
13818 windows as accurate. If ACCURATE_P is zero, arrange for windows to
13819 be redisplayed the next time redisplay_internal is called. */
13822 mark_window_display_accurate (Lisp_Object window
, int accurate_p
)
13826 for (; !NILP (window
); window
= w
->next
)
13828 w
= XWINDOW (window
);
13829 mark_window_display_accurate_1 (w
, accurate_p
);
13831 if (!NILP (w
->vchild
))
13832 mark_window_display_accurate (w
->vchild
, accurate_p
);
13833 if (!NILP (w
->hchild
))
13834 mark_window_display_accurate (w
->hchild
, accurate_p
);
13839 update_overlay_arrows (1);
13843 /* Force a thorough redisplay the next time by setting
13844 last_arrow_position and last_arrow_string to t, which is
13845 unequal to any useful value of Voverlay_arrow_... */
13846 update_overlay_arrows (-1);
13851 /* Return value in display table DP (Lisp_Char_Table *) for character
13852 C. Since a display table doesn't have any parent, we don't have to
13853 follow parent. Do not call this function directly but use the
13854 macro DISP_CHAR_VECTOR. */
13857 disp_char_vector (struct Lisp_Char_Table
*dp
, int c
)
13861 if (ASCII_CHAR_P (c
))
13864 if (SUB_CHAR_TABLE_P (val
))
13865 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
13871 XSETCHAR_TABLE (table
, dp
);
13872 val
= char_table_ref (table
, c
);
13881 /***********************************************************************
13883 ***********************************************************************/
13885 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
13888 redisplay_windows (Lisp_Object window
)
13890 while (!NILP (window
))
13892 struct window
*w
= XWINDOW (window
);
13894 if (!NILP (w
->hchild
))
13895 redisplay_windows (w
->hchild
);
13896 else if (!NILP (w
->vchild
))
13897 redisplay_windows (w
->vchild
);
13898 else if (!NILP (w
->buffer
))
13900 displayed_buffer
= XBUFFER (w
->buffer
);
13901 /* Use list_of_error, not Qerror, so that
13902 we catch only errors and don't run the debugger. */
13903 internal_condition_case_1 (redisplay_window_0
, window
,
13905 redisplay_window_error
);
13913 redisplay_window_error (Lisp_Object ignore
)
13915 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
13920 redisplay_window_0 (Lisp_Object window
)
13922 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13923 redisplay_window (window
, 0);
13928 redisplay_window_1 (Lisp_Object window
)
13930 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13931 redisplay_window (window
, 1);
13936 /* Set cursor position of W. PT is assumed to be displayed in ROW.
13937 DELTA and DELTA_BYTES are the numbers of characters and bytes by
13938 which positions recorded in ROW differ from current buffer
13941 Return 0 if cursor is not on this row, 1 otherwise. */
13944 set_cursor_from_row (struct window
*w
, struct glyph_row
*row
,
13945 struct glyph_matrix
*matrix
,
13946 ptrdiff_t delta
, ptrdiff_t delta_bytes
,
13949 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
13950 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
13951 struct glyph
*cursor
= NULL
;
13952 /* The last known character position in row. */
13953 ptrdiff_t last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13955 ptrdiff_t pt_old
= PT
- delta
;
13956 ptrdiff_t pos_before
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13957 ptrdiff_t pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
13958 struct glyph
*glyph_before
= glyph
- 1, *glyph_after
= end
;
13959 /* A glyph beyond the edge of TEXT_AREA which we should never
13961 struct glyph
*glyphs_end
= end
;
13962 /* Non-zero means we've found a match for cursor position, but that
13963 glyph has the avoid_cursor_p flag set. */
13964 int match_with_avoid_cursor
= 0;
13965 /* Non-zero means we've seen at least one glyph that came from a
13967 int string_seen
= 0;
13968 /* Largest and smallest buffer positions seen so far during scan of
13970 ptrdiff_t bpos_max
= pos_before
;
13971 ptrdiff_t bpos_min
= pos_after
;
13972 /* Last buffer position covered by an overlay string with an integer
13973 `cursor' property. */
13974 ptrdiff_t bpos_covered
= 0;
13975 /* Non-zero means the display string on which to display the cursor
13976 comes from a text property, not from an overlay. */
13977 int string_from_text_prop
= 0;
13979 /* Don't even try doing anything if called for a mode-line or
13980 header-line row, since the rest of the code isn't prepared to
13981 deal with such calamities. */
13982 eassert (!row
->mode_line_p
);
13983 if (row
->mode_line_p
)
13986 /* Skip over glyphs not having an object at the start and the end of
13987 the row. These are special glyphs like truncation marks on
13988 terminal frames. */
13989 if (row
->displays_text_p
)
13991 if (!row
->reversed_p
)
13994 && INTEGERP (glyph
->object
)
13995 && glyph
->charpos
< 0)
13997 x
+= glyph
->pixel_width
;
14001 && INTEGERP ((end
- 1)->object
)
14002 /* CHARPOS is zero for blanks and stretch glyphs
14003 inserted by extend_face_to_end_of_line. */
14004 && (end
- 1)->charpos
<= 0)
14006 glyph_before
= glyph
- 1;
14013 /* If the glyph row is reversed, we need to process it from back
14014 to front, so swap the edge pointers. */
14015 glyphs_end
= end
= glyph
- 1;
14016 glyph
+= row
->used
[TEXT_AREA
] - 1;
14018 while (glyph
> end
+ 1
14019 && INTEGERP (glyph
->object
)
14020 && glyph
->charpos
< 0)
14023 x
-= glyph
->pixel_width
;
14025 if (INTEGERP (glyph
->object
) && glyph
->charpos
< 0)
14027 /* By default, in reversed rows we put the cursor on the
14028 rightmost (first in the reading order) glyph. */
14029 for (g
= end
+ 1; g
< glyph
; g
++)
14030 x
+= g
->pixel_width
;
14032 && INTEGERP ((end
+ 1)->object
)
14033 && (end
+ 1)->charpos
<= 0)
14035 glyph_before
= glyph
+ 1;
14039 else if (row
->reversed_p
)
14041 /* In R2L rows that don't display text, put the cursor on the
14042 rightmost glyph. Case in point: an empty last line that is
14043 part of an R2L paragraph. */
14045 /* Avoid placing the cursor on the last glyph of the row, where
14046 on terminal frames we hold the vertical border between
14047 adjacent windows. */
14048 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w
))
14049 && !WINDOW_RIGHTMOST_P (w
)
14050 && cursor
== row
->glyphs
[LAST_AREA
] - 1)
14052 x
= -1; /* will be computed below, at label compute_x */
14055 /* Step 1: Try to find the glyph whose character position
14056 corresponds to point. If that's not possible, find 2 glyphs
14057 whose character positions are the closest to point, one before
14058 point, the other after it. */
14059 if (!row
->reversed_p
)
14060 while (/* not marched to end of glyph row */
14062 /* glyph was not inserted by redisplay for internal purposes */
14063 && !INTEGERP (glyph
->object
))
14065 if (BUFFERP (glyph
->object
))
14067 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14069 if (glyph
->charpos
> bpos_max
)
14070 bpos_max
= glyph
->charpos
;
14071 if (glyph
->charpos
< bpos_min
)
14072 bpos_min
= glyph
->charpos
;
14073 if (!glyph
->avoid_cursor_p
)
14075 /* If we hit point, we've found the glyph on which to
14076 display the cursor. */
14079 match_with_avoid_cursor
= 0;
14082 /* See if we've found a better approximation to
14083 POS_BEFORE or to POS_AFTER. */
14084 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14086 pos_before
= glyph
->charpos
;
14087 glyph_before
= glyph
;
14089 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14091 pos_after
= glyph
->charpos
;
14092 glyph_after
= glyph
;
14095 else if (dpos
== 0)
14096 match_with_avoid_cursor
= 1;
14098 else if (STRINGP (glyph
->object
))
14100 Lisp_Object chprop
;
14101 ptrdiff_t glyph_pos
= glyph
->charpos
;
14103 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14105 if (!NILP (chprop
))
14107 /* If the string came from a `display' text property,
14108 look up the buffer position of that property and
14109 use that position to update bpos_max, as if we
14110 actually saw such a position in one of the row's
14111 glyphs. This helps with supporting integer values
14112 of `cursor' property on the display string in
14113 situations where most or all of the row's buffer
14114 text is completely covered by display properties,
14115 so that no glyph with valid buffer positions is
14116 ever seen in the row. */
14117 ptrdiff_t prop_pos
=
14118 string_buffer_position_lim (glyph
->object
, pos_before
,
14121 if (prop_pos
>= pos_before
)
14122 bpos_max
= prop_pos
- 1;
14124 if (INTEGERP (chprop
))
14126 bpos_covered
= bpos_max
+ XINT (chprop
);
14127 /* If the `cursor' property covers buffer positions up
14128 to and including point, we should display cursor on
14129 this glyph. Note that, if a `cursor' property on one
14130 of the string's characters has an integer value, we
14131 will break out of the loop below _before_ we get to
14132 the position match above. IOW, integer values of
14133 the `cursor' property override the "exact match for
14134 point" strategy of positioning the cursor. */
14135 /* Implementation note: bpos_max == pt_old when, e.g.,
14136 we are in an empty line, where bpos_max is set to
14137 MATRIX_ROW_START_CHARPOS, see above. */
14138 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14147 x
+= glyph
->pixel_width
;
14150 else if (glyph
> end
) /* row is reversed */
14151 while (!INTEGERP (glyph
->object
))
14153 if (BUFFERP (glyph
->object
))
14155 ptrdiff_t dpos
= glyph
->charpos
- pt_old
;
14157 if (glyph
->charpos
> bpos_max
)
14158 bpos_max
= glyph
->charpos
;
14159 if (glyph
->charpos
< bpos_min
)
14160 bpos_min
= glyph
->charpos
;
14161 if (!glyph
->avoid_cursor_p
)
14165 match_with_avoid_cursor
= 0;
14168 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
14170 pos_before
= glyph
->charpos
;
14171 glyph_before
= glyph
;
14173 else if (0 < dpos
&& dpos
< pos_after
- pt_old
)
14175 pos_after
= glyph
->charpos
;
14176 glyph_after
= glyph
;
14179 else if (dpos
== 0)
14180 match_with_avoid_cursor
= 1;
14182 else if (STRINGP (glyph
->object
))
14184 Lisp_Object chprop
;
14185 ptrdiff_t glyph_pos
= glyph
->charpos
;
14187 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
14189 if (!NILP (chprop
))
14191 ptrdiff_t prop_pos
=
14192 string_buffer_position_lim (glyph
->object
, pos_before
,
14195 if (prop_pos
>= pos_before
)
14196 bpos_max
= prop_pos
- 1;
14198 if (INTEGERP (chprop
))
14200 bpos_covered
= bpos_max
+ XINT (chprop
);
14201 /* If the `cursor' property covers buffer positions up
14202 to and including point, we should display cursor on
14204 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
14213 if (glyph
== glyphs_end
) /* don't dereference outside TEXT_AREA */
14215 x
--; /* can't use any pixel_width */
14218 x
-= glyph
->pixel_width
;
14221 /* Step 2: If we didn't find an exact match for point, we need to
14222 look for a proper place to put the cursor among glyphs between
14223 GLYPH_BEFORE and GLYPH_AFTER. */
14224 if (!((row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14225 && BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14226 && !(bpos_max
< pt_old
&& pt_old
<= bpos_covered
))
14228 /* An empty line has a single glyph whose OBJECT is zero and
14229 whose CHARPOS is the position of a newline on that line.
14230 Note that on a TTY, there are more glyphs after that, which
14231 were produced by extend_face_to_end_of_line, but their
14232 CHARPOS is zero or negative. */
14234 (row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
14235 && INTEGERP (glyph
->object
) && glyph
->charpos
> 0;
14237 if (row
->ends_in_ellipsis_p
&& pos_after
== last_pos
)
14239 ptrdiff_t ellipsis_pos
;
14241 /* Scan back over the ellipsis glyphs. */
14242 if (!row
->reversed_p
)
14244 ellipsis_pos
= (glyph
- 1)->charpos
;
14245 while (glyph
> row
->glyphs
[TEXT_AREA
]
14246 && (glyph
- 1)->charpos
== ellipsis_pos
)
14247 glyph
--, x
-= glyph
->pixel_width
;
14248 /* That loop always goes one position too far, including
14249 the glyph before the ellipsis. So scan forward over
14251 x
+= glyph
->pixel_width
;
14254 else /* row is reversed */
14256 ellipsis_pos
= (glyph
+ 1)->charpos
;
14257 while (glyph
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14258 && (glyph
+ 1)->charpos
== ellipsis_pos
)
14259 glyph
++, x
+= glyph
->pixel_width
;
14260 x
-= glyph
->pixel_width
;
14264 else if (match_with_avoid_cursor
)
14266 cursor
= glyph_after
;
14269 else if (string_seen
)
14271 int incr
= row
->reversed_p
? -1 : +1;
14273 /* Need to find the glyph that came out of a string which is
14274 present at point. That glyph is somewhere between
14275 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
14276 positioned between POS_BEFORE and POS_AFTER in the
14278 struct glyph
*start
, *stop
;
14279 ptrdiff_t pos
= pos_before
;
14283 /* If the row ends in a newline from a display string,
14284 reordering could have moved the glyphs belonging to the
14285 string out of the [GLYPH_BEFORE..GLYPH_AFTER] range. So
14286 in this case we extend the search to the last glyph in
14287 the row that was not inserted by redisplay. */
14288 if (row
->ends_in_newline_from_string_p
)
14291 pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
14294 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
14295 correspond to POS_BEFORE and POS_AFTER, respectively. We
14296 need START and STOP in the order that corresponds to the
14297 row's direction as given by its reversed_p flag. If the
14298 directionality of characters between POS_BEFORE and
14299 POS_AFTER is the opposite of the row's base direction,
14300 these characters will have been reordered for display,
14301 and we need to reverse START and STOP. */
14302 if (!row
->reversed_p
)
14304 start
= min (glyph_before
, glyph_after
);
14305 stop
= max (glyph_before
, glyph_after
);
14309 start
= max (glyph_before
, glyph_after
);
14310 stop
= min (glyph_before
, glyph_after
);
14312 for (glyph
= start
+ incr
;
14313 row
->reversed_p
? glyph
> stop
: glyph
< stop
; )
14316 /* Any glyphs that come from the buffer are here because
14317 of bidi reordering. Skip them, and only pay
14318 attention to glyphs that came from some string. */
14319 if (STRINGP (glyph
->object
))
14323 /* If the display property covers the newline, we
14324 need to search for it one position farther. */
14325 ptrdiff_t lim
= pos_after
14326 + (pos_after
== MATRIX_ROW_END_CHARPOS (row
) + delta
);
14328 string_from_text_prop
= 0;
14329 str
= glyph
->object
;
14330 tem
= string_buffer_position_lim (str
, pos
, lim
, 0);
14331 if (tem
== 0 /* from overlay */
14334 /* If the string from which this glyph came is
14335 found in the buffer at point, or at position
14336 that is closer to point than pos_after, then
14337 we've found the glyph we've been looking for.
14338 If it comes from an overlay (tem == 0), and
14339 it has the `cursor' property on one of its
14340 glyphs, record that glyph as a candidate for
14341 displaying the cursor. (As in the
14342 unidirectional version, we will display the
14343 cursor on the last candidate we find.) */
14346 || (tem
- pt_old
> 0 && tem
< pos_after
))
14348 /* The glyphs from this string could have
14349 been reordered. Find the one with the
14350 smallest string position. Or there could
14351 be a character in the string with the
14352 `cursor' property, which means display
14353 cursor on that character's glyph. */
14354 ptrdiff_t strpos
= glyph
->charpos
;
14359 string_from_text_prop
= 1;
14362 (row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14363 && EQ (glyph
->object
, str
);
14367 ptrdiff_t gpos
= glyph
->charpos
;
14369 cprop
= Fget_char_property (make_number (gpos
),
14377 if (tem
&& glyph
->charpos
< strpos
)
14379 strpos
= glyph
->charpos
;
14385 || (tem
- pt_old
> 0 && tem
< pos_after
))
14389 pos
= tem
+ 1; /* don't find previous instances */
14391 /* This string is not what we want; skip all of the
14392 glyphs that came from it. */
14393 while ((row
->reversed_p
? glyph
> stop
: glyph
< stop
)
14394 && EQ (glyph
->object
, str
))
14401 /* If we reached the end of the line, and END was from a string,
14402 the cursor is not on this line. */
14404 && (row
->reversed_p
? glyph
<= end
: glyph
>= end
)
14405 && (row
->reversed_p
? end
> glyphs_end
: end
< glyphs_end
)
14406 && STRINGP (end
->object
)
14407 && row
->continued_p
)
14410 /* A truncated row may not include PT among its character positions.
14411 Setting the cursor inside the scroll margin will trigger
14412 recalculation of hscroll in hscroll_window_tree. But if a
14413 display string covers point, defer to the string-handling
14414 code below to figure this out. */
14415 else if (row
->truncated_on_left_p
&& pt_old
< bpos_min
)
14417 cursor
= glyph_before
;
14420 else if ((row
->truncated_on_right_p
&& pt_old
> bpos_max
)
14421 /* Zero-width characters produce no glyphs. */
14423 && (row
->reversed_p
14424 ? glyph_after
> glyphs_end
14425 : glyph_after
< glyphs_end
)))
14427 cursor
= glyph_after
;
14433 if (cursor
!= NULL
)
14435 else if (glyph
== glyphs_end
14436 && pos_before
== pos_after
14437 && STRINGP ((row
->reversed_p
14438 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14439 : row
->glyphs
[TEXT_AREA
])->object
))
14441 /* If all the glyphs of this row came from strings, put the
14442 cursor on the first glyph of the row. This avoids having the
14443 cursor outside of the text area in this very rare and hard
14447 ? row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
14448 : row
->glyphs
[TEXT_AREA
];
14454 /* Need to compute x that corresponds to GLYPH. */
14455 for (g
= row
->glyphs
[TEXT_AREA
], x
= row
->x
; g
< glyph
; g
++)
14457 if (g
>= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
])
14459 x
+= g
->pixel_width
;
14463 /* ROW could be part of a continued line, which, under bidi
14464 reordering, might have other rows whose start and end charpos
14465 occlude point. Only set w->cursor if we found a better
14466 approximation to the cursor position than we have from previously
14467 examined candidate rows belonging to the same continued line. */
14468 if (/* we already have a candidate row */
14469 w
->cursor
.vpos
>= 0
14470 /* that candidate is not the row we are processing */
14471 && MATRIX_ROW (matrix
, w
->cursor
.vpos
) != row
14472 /* Make sure cursor.vpos specifies a row whose start and end
14473 charpos occlude point, and it is valid candidate for being a
14474 cursor-row. This is because some callers of this function
14475 leave cursor.vpos at the row where the cursor was displayed
14476 during the last redisplay cycle. */
14477 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)) <= pt_old
14478 && pt_old
<= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14479 && cursor_row_p (MATRIX_ROW (matrix
, w
->cursor
.vpos
)))
14482 MATRIX_ROW_GLYPH_START (matrix
, w
->cursor
.vpos
) + w
->cursor
.hpos
;
14484 /* Don't consider glyphs that are outside TEXT_AREA. */
14485 if (!(row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
))
14487 /* Keep the candidate whose buffer position is the closest to
14488 point or has the `cursor' property. */
14489 if (/* previous candidate is a glyph in TEXT_AREA of that row */
14490 w
->cursor
.hpos
>= 0
14491 && w
->cursor
.hpos
< MATRIX_ROW_USED (matrix
, w
->cursor
.vpos
)
14492 && ((BUFFERP (g1
->object
)
14493 && (g1
->charpos
== pt_old
/* an exact match always wins */
14494 || (BUFFERP (glyph
->object
)
14495 && eabs (g1
->charpos
- pt_old
)
14496 < eabs (glyph
->charpos
- pt_old
))))
14497 /* previous candidate is a glyph from a string that has
14498 a non-nil `cursor' property */
14499 || (STRINGP (g1
->object
)
14500 && (!NILP (Fget_char_property (make_number (g1
->charpos
),
14501 Qcursor
, g1
->object
))
14502 /* previous candidate is from the same display
14503 string as this one, and the display string
14504 came from a text property */
14505 || (EQ (g1
->object
, glyph
->object
)
14506 && string_from_text_prop
)
14507 /* this candidate is from newline and its
14508 position is not an exact match */
14509 || (INTEGERP (glyph
->object
)
14510 && glyph
->charpos
!= pt_old
)))))
14512 /* If this candidate gives an exact match, use that. */
14513 if (!((BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
14514 /* If this candidate is a glyph created for the
14515 terminating newline of a line, and point is on that
14516 newline, it wins because it's an exact match. */
14517 || (!row
->continued_p
14518 && INTEGERP (glyph
->object
)
14519 && glyph
->charpos
== 0
14520 && pt_old
== MATRIX_ROW_END_CHARPOS (row
) - 1))
14521 /* Otherwise, keep the candidate that comes from a row
14522 spanning less buffer positions. This may win when one or
14523 both candidate positions are on glyphs that came from
14524 display strings, for which we cannot compare buffer
14526 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14527 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
14528 < MATRIX_ROW_END_CHARPOS (row
) - MATRIX_ROW_START_CHARPOS (row
))
14531 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
14533 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
14534 w
->cursor
.y
= row
->y
+ dy
;
14536 if (w
== XWINDOW (selected_window
))
14538 if (!row
->continued_p
14539 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
14542 this_line_buffer
= XBUFFER (w
->buffer
);
14544 CHARPOS (this_line_start_pos
)
14545 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
14546 BYTEPOS (this_line_start_pos
)
14547 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
14549 CHARPOS (this_line_end_pos
)
14550 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
14551 BYTEPOS (this_line_end_pos
)
14552 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
14554 this_line_y
= w
->cursor
.y
;
14555 this_line_pixel_height
= row
->height
;
14556 this_line_vpos
= w
->cursor
.vpos
;
14557 this_line_start_x
= row
->x
;
14560 CHARPOS (this_line_start_pos
) = 0;
14567 /* Run window scroll functions, if any, for WINDOW with new window
14568 start STARTP. Sets the window start of WINDOW to that position.
14570 We assume that the window's buffer is really current. */
14572 static struct text_pos
14573 run_window_scroll_functions (Lisp_Object window
, struct text_pos startp
)
14575 struct window
*w
= XWINDOW (window
);
14576 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
14578 if (current_buffer
!= XBUFFER (w
->buffer
))
14581 if (!NILP (Vwindow_scroll_functions
))
14583 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
14584 make_number (CHARPOS (startp
)));
14585 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14586 /* In case the hook functions switch buffers. */
14587 set_buffer_internal (XBUFFER (w
->buffer
));
14594 /* Make sure the line containing the cursor is fully visible.
14595 A value of 1 means there is nothing to be done.
14596 (Either the line is fully visible, or it cannot be made so,
14597 or we cannot tell.)
14599 If FORCE_P is non-zero, return 0 even if partial visible cursor row
14600 is higher than window.
14602 A value of 0 means the caller should do scrolling
14603 as if point had gone off the screen. */
14606 cursor_row_fully_visible_p (struct window
*w
, int force_p
, int current_matrix_p
)
14608 struct glyph_matrix
*matrix
;
14609 struct glyph_row
*row
;
14612 if (!make_cursor_line_fully_visible_p
)
14615 /* It's not always possible to find the cursor, e.g, when a window
14616 is full of overlay strings. Don't do anything in that case. */
14617 if (w
->cursor
.vpos
< 0)
14620 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
14621 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
14623 /* If the cursor row is not partially visible, there's nothing to do. */
14624 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
14627 /* If the row the cursor is in is taller than the window's height,
14628 it's not clear what to do, so do nothing. */
14629 window_height
= window_box_height (w
);
14630 if (row
->height
>= window_height
)
14632 if (!force_p
|| MINI_WINDOW_P (w
)
14633 || w
->vscroll
|| w
->cursor
.vpos
== 0)
14640 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
14641 non-zero means only WINDOW is redisplayed in redisplay_internal.
14642 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
14643 in redisplay_window to bring a partially visible line into view in
14644 the case that only the cursor has moved.
14646 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
14647 last screen line's vertical height extends past the end of the screen.
14651 1 if scrolling succeeded
14653 0 if scrolling didn't find point.
14655 -1 if new fonts have been loaded so that we must interrupt
14656 redisplay, adjust glyph matrices, and try again. */
14662 SCROLLING_NEED_LARGER_MATRICES
14665 /* If scroll-conservatively is more than this, never recenter.
14667 If you change this, don't forget to update the doc string of
14668 `scroll-conservatively' and the Emacs manual. */
14669 #define SCROLL_LIMIT 100
14672 try_scrolling (Lisp_Object window
, int just_this_one_p
,
14673 ptrdiff_t arg_scroll_conservatively
, ptrdiff_t scroll_step
,
14674 int temp_scroll_step
, int last_line_misfit
)
14676 struct window
*w
= XWINDOW (window
);
14677 struct frame
*f
= XFRAME (w
->frame
);
14678 struct text_pos pos
, startp
;
14680 int this_scroll_margin
, scroll_max
, rc
, height
;
14681 int dy
= 0, amount_to_scroll
= 0, scroll_down_p
= 0;
14682 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
14683 Lisp_Object aggressive
;
14684 /* We will never try scrolling more than this number of lines. */
14685 int scroll_limit
= SCROLL_LIMIT
;
14688 debug_method_add (w
, "try_scrolling");
14691 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14693 /* Compute scroll margin height in pixels. We scroll when point is
14694 within this distance from the top or bottom of the window. */
14695 if (scroll_margin
> 0)
14696 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
14697 * FRAME_LINE_HEIGHT (f
);
14699 this_scroll_margin
= 0;
14701 /* Force arg_scroll_conservatively to have a reasonable value, to
14702 avoid scrolling too far away with slow move_it_* functions. Note
14703 that the user can supply scroll-conservatively equal to
14704 `most-positive-fixnum', which can be larger than INT_MAX. */
14705 if (arg_scroll_conservatively
> scroll_limit
)
14707 arg_scroll_conservatively
= scroll_limit
+ 1;
14708 scroll_max
= scroll_limit
* FRAME_LINE_HEIGHT (f
);
14710 else if (scroll_step
|| arg_scroll_conservatively
|| temp_scroll_step
)
14711 /* Compute how much we should try to scroll maximally to bring
14712 point into view. */
14713 scroll_max
= (max (scroll_step
,
14714 max (arg_scroll_conservatively
, temp_scroll_step
))
14715 * FRAME_LINE_HEIGHT (f
));
14716 else if (NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
))
14717 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
)))
14718 /* We're trying to scroll because of aggressive scrolling but no
14719 scroll_step is set. Choose an arbitrary one. */
14720 scroll_max
= 10 * FRAME_LINE_HEIGHT (f
);
14726 /* Decide whether to scroll down. */
14727 if (PT
> CHARPOS (startp
))
14729 int scroll_margin_y
;
14731 /* Compute the pixel ypos of the scroll margin, then move IT to
14732 either that ypos or PT, whichever comes first. */
14733 start_display (&it
, w
, startp
);
14734 scroll_margin_y
= it
.last_visible_y
- this_scroll_margin
14735 - FRAME_LINE_HEIGHT (f
) * extra_scroll_margin_lines
;
14736 move_it_to (&it
, PT
, -1, scroll_margin_y
- 1, -1,
14737 (MOVE_TO_POS
| MOVE_TO_Y
));
14739 if (PT
> CHARPOS (it
.current
.pos
))
14741 int y0
= line_bottom_y (&it
);
14742 /* Compute how many pixels below window bottom to stop searching
14743 for PT. This avoids costly search for PT that is far away if
14744 the user limited scrolling by a small number of lines, but
14745 always finds PT if scroll_conservatively is set to a large
14746 number, such as most-positive-fixnum. */
14747 int slack
= max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
));
14748 int y_to_move
= it
.last_visible_y
+ slack
;
14750 /* Compute the distance from the scroll margin to PT or to
14751 the scroll limit, whichever comes first. This should
14752 include the height of the cursor line, to make that line
14754 move_it_to (&it
, PT
, -1, y_to_move
,
14755 -1, MOVE_TO_POS
| MOVE_TO_Y
);
14756 dy
= line_bottom_y (&it
) - y0
;
14758 if (dy
> scroll_max
)
14759 return SCROLLING_FAILED
;
14768 /* Point is in or below the bottom scroll margin, so move the
14769 window start down. If scrolling conservatively, move it just
14770 enough down to make point visible. If scroll_step is set,
14771 move it down by scroll_step. */
14772 if (arg_scroll_conservatively
)
14774 = min (max (dy
, FRAME_LINE_HEIGHT (f
)),
14775 FRAME_LINE_HEIGHT (f
) * arg_scroll_conservatively
);
14776 else if (scroll_step
|| temp_scroll_step
)
14777 amount_to_scroll
= scroll_max
;
14780 aggressive
= BVAR (current_buffer
, scroll_up_aggressively
);
14781 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
14782 if (NUMBERP (aggressive
))
14784 double float_amount
= XFLOATINT (aggressive
) * height
;
14785 int aggressive_scroll
= float_amount
;
14786 if (aggressive_scroll
== 0 && float_amount
> 0)
14787 aggressive_scroll
= 1;
14788 /* Don't let point enter the scroll margin near top of
14789 the window. This could happen if the value of
14790 scroll_up_aggressively is too large and there are
14791 non-zero margins, because scroll_up_aggressively
14792 means put point that fraction of window height
14793 _from_the_bottom_margin_. */
14794 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
14795 aggressive_scroll
= height
- 2*this_scroll_margin
;
14796 amount_to_scroll
= dy
+ aggressive_scroll
;
14800 if (amount_to_scroll
<= 0)
14801 return SCROLLING_FAILED
;
14803 start_display (&it
, w
, startp
);
14804 if (arg_scroll_conservatively
<= scroll_limit
)
14805 move_it_vertically (&it
, amount_to_scroll
);
14808 /* Extra precision for users who set scroll-conservatively
14809 to a large number: make sure the amount we scroll
14810 the window start is never less than amount_to_scroll,
14811 which was computed as distance from window bottom to
14812 point. This matters when lines at window top and lines
14813 below window bottom have different height. */
14815 void *it1data
= NULL
;
14816 /* We use a temporary it1 because line_bottom_y can modify
14817 its argument, if it moves one line down; see there. */
14820 SAVE_IT (it1
, it
, it1data
);
14821 start_y
= line_bottom_y (&it1
);
14823 RESTORE_IT (&it
, &it
, it1data
);
14824 move_it_by_lines (&it
, 1);
14825 SAVE_IT (it1
, it
, it1data
);
14826 } while (line_bottom_y (&it1
) - start_y
< amount_to_scroll
);
14829 /* If STARTP is unchanged, move it down another screen line. */
14830 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
14831 move_it_by_lines (&it
, 1);
14832 startp
= it
.current
.pos
;
14836 struct text_pos scroll_margin_pos
= startp
;
14838 /* See if point is inside the scroll margin at the top of the
14840 if (this_scroll_margin
)
14842 start_display (&it
, w
, startp
);
14843 move_it_vertically (&it
, this_scroll_margin
);
14844 scroll_margin_pos
= it
.current
.pos
;
14847 if (PT
< CHARPOS (scroll_margin_pos
))
14849 /* Point is in the scroll margin at the top of the window or
14850 above what is displayed in the window. */
14853 /* Compute the vertical distance from PT to the scroll
14854 margin position. Move as far as scroll_max allows, or
14855 one screenful, or 10 screen lines, whichever is largest.
14856 Give up if distance is greater than scroll_max or if we
14857 didn't reach the scroll margin position. */
14858 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
14859 start_display (&it
, w
, pos
);
14861 y_to_move
= max (it
.last_visible_y
,
14862 max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
)));
14863 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
14865 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
14866 dy
= it
.current_y
- y0
;
14867 if (dy
> scroll_max
14868 || IT_CHARPOS (it
) < CHARPOS (scroll_margin_pos
))
14869 return SCROLLING_FAILED
;
14871 /* Compute new window start. */
14872 start_display (&it
, w
, startp
);
14874 if (arg_scroll_conservatively
)
14875 amount_to_scroll
= max (dy
, FRAME_LINE_HEIGHT (f
) *
14876 max (scroll_step
, temp_scroll_step
));
14877 else if (scroll_step
|| temp_scroll_step
)
14878 amount_to_scroll
= scroll_max
;
14881 aggressive
= BVAR (current_buffer
, scroll_down_aggressively
);
14882 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
14883 if (NUMBERP (aggressive
))
14885 double float_amount
= XFLOATINT (aggressive
) * height
;
14886 int aggressive_scroll
= float_amount
;
14887 if (aggressive_scroll
== 0 && float_amount
> 0)
14888 aggressive_scroll
= 1;
14889 /* Don't let point enter the scroll margin near
14890 bottom of the window, if the value of
14891 scroll_down_aggressively happens to be too
14893 if (aggressive_scroll
+ 2*this_scroll_margin
> height
)
14894 aggressive_scroll
= height
- 2*this_scroll_margin
;
14895 amount_to_scroll
= dy
+ aggressive_scroll
;
14899 if (amount_to_scroll
<= 0)
14900 return SCROLLING_FAILED
;
14902 move_it_vertically_backward (&it
, amount_to_scroll
);
14903 startp
= it
.current
.pos
;
14907 /* Run window scroll functions. */
14908 startp
= run_window_scroll_functions (window
, startp
);
14910 /* Display the window. Give up if new fonts are loaded, or if point
14912 if (!try_window (window
, startp
, 0))
14913 rc
= SCROLLING_NEED_LARGER_MATRICES
;
14914 else if (w
->cursor
.vpos
< 0)
14916 clear_glyph_matrix (w
->desired_matrix
);
14917 rc
= SCROLLING_FAILED
;
14921 /* Maybe forget recorded base line for line number display. */
14922 if (!just_this_one_p
14923 || current_buffer
->clip_changed
14924 || BEG_UNCHANGED
< CHARPOS (startp
))
14925 wset_base_line_number (w
, Qnil
);
14927 /* If cursor ends up on a partially visible line,
14928 treat that as being off the bottom of the screen. */
14929 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0)
14930 /* It's possible that the cursor is on the first line of the
14931 buffer, which is partially obscured due to a vscroll
14932 (Bug#7537). In that case, avoid looping forever . */
14933 && extra_scroll_margin_lines
< w
->desired_matrix
->nrows
- 1)
14935 clear_glyph_matrix (w
->desired_matrix
);
14936 ++extra_scroll_margin_lines
;
14939 rc
= SCROLLING_SUCCESS
;
14946 /* Compute a suitable window start for window W if display of W starts
14947 on a continuation line. Value is non-zero if a new window start
14950 The new window start will be computed, based on W's width, starting
14951 from the start of the continued line. It is the start of the
14952 screen line with the minimum distance from the old start W->start. */
14955 compute_window_start_on_continuation_line (struct window
*w
)
14957 struct text_pos pos
, start_pos
;
14958 int window_start_changed_p
= 0;
14960 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
14962 /* If window start is on a continuation line... Window start may be
14963 < BEGV in case there's invisible text at the start of the
14964 buffer (M-x rmail, for example). */
14965 if (CHARPOS (start_pos
) > BEGV
14966 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
14969 struct glyph_row
*row
;
14971 /* Handle the case that the window start is out of range. */
14972 if (CHARPOS (start_pos
) < BEGV
)
14973 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
14974 else if (CHARPOS (start_pos
) > ZV
)
14975 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
14977 /* Find the start of the continued line. This should be fast
14978 because scan_buffer is fast (newline cache). */
14979 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
14980 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
14981 row
, DEFAULT_FACE_ID
);
14982 reseat_at_previous_visible_line_start (&it
);
14984 /* If the line start is "too far" away from the window start,
14985 say it takes too much time to compute a new window start. */
14986 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
14987 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
14989 int min_distance
, distance
;
14991 /* Move forward by display lines to find the new window
14992 start. If window width was enlarged, the new start can
14993 be expected to be > the old start. If window width was
14994 decreased, the new window start will be < the old start.
14995 So, we're looking for the display line start with the
14996 minimum distance from the old window start. */
14997 pos
= it
.current
.pos
;
14998 min_distance
= INFINITY
;
14999 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
15000 distance
< min_distance
)
15002 min_distance
= distance
;
15003 pos
= it
.current
.pos
;
15004 move_it_by_lines (&it
, 1);
15007 /* Set the window start there. */
15008 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
15009 window_start_changed_p
= 1;
15013 return window_start_changed_p
;
15017 /* Try cursor movement in case text has not changed in window WINDOW,
15018 with window start STARTP. Value is
15020 CURSOR_MOVEMENT_SUCCESS if successful
15022 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
15024 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
15025 display. *SCROLL_STEP is set to 1, under certain circumstances, if
15026 we want to scroll as if scroll-step were set to 1. See the code.
15028 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
15029 which case we have to abort this redisplay, and adjust matrices
15034 CURSOR_MOVEMENT_SUCCESS
,
15035 CURSOR_MOVEMENT_CANNOT_BE_USED
,
15036 CURSOR_MOVEMENT_MUST_SCROLL
,
15037 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
15041 try_cursor_movement (Lisp_Object window
, struct text_pos startp
, int *scroll_step
)
15043 struct window
*w
= XWINDOW (window
);
15044 struct frame
*f
= XFRAME (w
->frame
);
15045 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
15048 if (inhibit_try_cursor_movement
)
15052 /* Previously, there was a check for Lisp integer in the
15053 if-statement below. Now, this field is converted to
15054 ptrdiff_t, thus zero means invalid position in a buffer. */
15055 eassert (w
->last_point
> 0);
15057 /* Handle case where text has not changed, only point, and it has
15058 not moved off the frame. */
15059 if (/* Point may be in this window. */
15060 PT
>= CHARPOS (startp
)
15061 /* Selective display hasn't changed. */
15062 && !current_buffer
->clip_changed
15063 /* Function force-mode-line-update is used to force a thorough
15064 redisplay. It sets either windows_or_buffers_changed or
15065 update_mode_lines. So don't take a shortcut here for these
15067 && !update_mode_lines
15068 && !windows_or_buffers_changed
15069 && !cursor_type_changed
15070 /* Can't use this case if highlighting a region. When a
15071 region exists, cursor movement has to do more than just
15073 && !(!NILP (Vtransient_mark_mode
)
15074 && !NILP (BVAR (current_buffer
, mark_active
)))
15075 && NILP (w
->region_showing
)
15076 && NILP (Vshow_trailing_whitespace
)
15077 /* This code is not used for mini-buffer for the sake of the case
15078 of redisplaying to replace an echo area message; since in
15079 that case the mini-buffer contents per se are usually
15080 unchanged. This code is of no real use in the mini-buffer
15081 since the handling of this_line_start_pos, etc., in redisplay
15082 handles the same cases. */
15083 && !EQ (window
, minibuf_window
)
15084 /* When splitting windows or for new windows, it happens that
15085 redisplay is called with a nil window_end_vpos or one being
15086 larger than the window. This should really be fixed in
15087 window.c. I don't have this on my list, now, so we do
15088 approximately the same as the old redisplay code. --gerd. */
15089 && INTEGERP (w
->window_end_vpos
)
15090 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
15091 && (FRAME_WINDOW_P (f
)
15092 || !overlay_arrow_in_current_buffer_p ()))
15094 int this_scroll_margin
, top_scroll_margin
;
15095 struct glyph_row
*row
= NULL
;
15098 debug_method_add (w
, "cursor movement");
15101 /* Scroll if point within this distance from the top or bottom
15102 of the window. This is a pixel value. */
15103 if (scroll_margin
> 0)
15105 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15106 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
15109 this_scroll_margin
= 0;
15111 top_scroll_margin
= this_scroll_margin
;
15112 if (WINDOW_WANTS_HEADER_LINE_P (w
))
15113 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
15115 /* Start with the row the cursor was displayed during the last
15116 not paused redisplay. Give up if that row is not valid. */
15117 if (w
->last_cursor
.vpos
< 0
15118 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
15119 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15122 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
15123 if (row
->mode_line_p
)
15125 if (!row
->enabled_p
)
15126 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15129 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
15131 int scroll_p
= 0, must_scroll
= 0;
15132 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
15134 if (PT
> w
->last_point
)
15136 /* Point has moved forward. */
15137 while (MATRIX_ROW_END_CHARPOS (row
) < PT
15138 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
15140 eassert (row
->enabled_p
);
15144 /* If the end position of a row equals the start
15145 position of the next row, and PT is at that position,
15146 we would rather display cursor in the next line. */
15147 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15148 && MATRIX_ROW_END_CHARPOS (row
) == PT
15149 && row
< w
->current_matrix
->rows
15150 + w
->current_matrix
->nrows
- 1
15151 && MATRIX_ROW_START_CHARPOS (row
+1) == PT
15152 && !cursor_row_p (row
))
15155 /* If within the scroll margin, scroll. Note that
15156 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
15157 the next line would be drawn, and that
15158 this_scroll_margin can be zero. */
15159 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
15160 || PT
> MATRIX_ROW_END_CHARPOS (row
)
15161 /* Line is completely visible last line in window
15162 and PT is to be set in the next line. */
15163 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
15164 && PT
== MATRIX_ROW_END_CHARPOS (row
)
15165 && !row
->ends_at_zv_p
15166 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
15169 else if (PT
< w
->last_point
)
15171 /* Cursor has to be moved backward. Note that PT >=
15172 CHARPOS (startp) because of the outer if-statement. */
15173 while (!row
->mode_line_p
15174 && (MATRIX_ROW_START_CHARPOS (row
) > PT
15175 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15176 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
15177 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
15178 row
> w
->current_matrix
->rows
15179 && (row
-1)->ends_in_newline_from_string_p
))))
15180 && (row
->y
> top_scroll_margin
15181 || CHARPOS (startp
) == BEGV
))
15183 eassert (row
->enabled_p
);
15187 /* Consider the following case: Window starts at BEGV,
15188 there is invisible, intangible text at BEGV, so that
15189 display starts at some point START > BEGV. It can
15190 happen that we are called with PT somewhere between
15191 BEGV and START. Try to handle that case. */
15192 if (row
< w
->current_matrix
->rows
15193 || row
->mode_line_p
)
15195 row
= w
->current_matrix
->rows
;
15196 if (row
->mode_line_p
)
15200 /* Due to newlines in overlay strings, we may have to
15201 skip forward over overlay strings. */
15202 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15203 && MATRIX_ROW_END_CHARPOS (row
) == PT
15204 && !cursor_row_p (row
))
15207 /* If within the scroll margin, scroll. */
15208 if (row
->y
< top_scroll_margin
15209 && CHARPOS (startp
) != BEGV
)
15214 /* Cursor did not move. So don't scroll even if cursor line
15215 is partially visible, as it was so before. */
15216 rc
= CURSOR_MOVEMENT_SUCCESS
;
15219 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
15220 || PT
> MATRIX_ROW_END_CHARPOS (row
))
15222 /* if PT is not in the glyph row, give up. */
15223 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15226 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15227 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15229 struct glyph_row
*row1
;
15231 /* If rows are bidi-reordered and point moved, back up
15232 until we find a row that does not belong to a
15233 continuation line. This is because we must consider
15234 all rows of a continued line as candidates for the
15235 new cursor positioning, since row start and end
15236 positions change non-linearly with vertical position
15238 /* FIXME: Revisit this when glyph ``spilling'' in
15239 continuation lines' rows is implemented for
15240 bidi-reordered rows. */
15241 for (row1
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15242 MATRIX_ROW_CONTINUATION_LINE_P (row
);
15245 /* If we hit the beginning of the displayed portion
15246 without finding the first row of a continued
15250 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15253 eassert (row
->enabled_p
);
15258 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15259 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
15260 /* Make sure this isn't a header line by any chance, since
15261 then MATRIX_ROW_PARTIALLY_VISIBLE_P might yield non-zero. */
15262 && !row
->mode_line_p
15263 && make_cursor_line_fully_visible_p
)
15265 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
15266 && !row
->ends_at_zv_p
15267 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
15268 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15269 else if (row
->height
> window_box_height (w
))
15271 /* If we end up in a partially visible line, let's
15272 make it fully visible, except when it's taller
15273 than the window, in which case we can't do much
15276 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15280 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15281 if (!cursor_row_fully_visible_p (w
, 0, 1))
15282 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15284 rc
= CURSOR_MOVEMENT_SUCCESS
;
15288 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15289 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
15290 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15292 /* With bidi-reordered rows, there could be more than
15293 one candidate row whose start and end positions
15294 occlude point. We need to let set_cursor_from_row
15295 find the best candidate. */
15296 /* FIXME: Revisit this when glyph ``spilling'' in
15297 continuation lines' rows is implemented for
15298 bidi-reordered rows. */
15303 int at_zv_p
= 0, exact_match_p
= 0;
15305 if (MATRIX_ROW_START_CHARPOS (row
) <= PT
15306 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
15307 && cursor_row_p (row
))
15308 rv
|= set_cursor_from_row (w
, row
, w
->current_matrix
,
15310 /* As soon as we've found the exact match for point,
15311 or the first suitable row whose ends_at_zv_p flag
15312 is set, we are done. */
15314 MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
)->ends_at_zv_p
;
15316 && w
->cursor
.hpos
>= 0
15317 && w
->cursor
.hpos
< MATRIX_ROW_USED (w
->current_matrix
,
15320 struct glyph_row
*candidate
=
15321 MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
15323 candidate
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
15324 ptrdiff_t endpos
= MATRIX_ROW_END_CHARPOS (candidate
);
15327 (BUFFERP (g
->object
) && g
->charpos
== PT
)
15328 || (INTEGERP (g
->object
)
15329 && (g
->charpos
== PT
15330 || (g
->charpos
== 0 && endpos
- 1 == PT
)));
15332 if (rv
&& (at_zv_p
|| exact_match_p
))
15334 rc
= CURSOR_MOVEMENT_SUCCESS
;
15337 if (MATRIX_ROW_BOTTOM_Y (row
) == last_y
)
15341 while (((MATRIX_ROW_CONTINUATION_LINE_P (row
)
15342 || row
->continued_p
)
15343 && MATRIX_ROW_BOTTOM_Y (row
) <= last_y
)
15344 || (MATRIX_ROW_START_CHARPOS (row
) == PT
15345 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
));
15346 /* If we didn't find any candidate rows, or exited the
15347 loop before all the candidates were examined, signal
15348 to the caller that this method failed. */
15349 if (rc
!= CURSOR_MOVEMENT_SUCCESS
15351 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
15352 && !row
->continued_p
))
15353 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
15355 rc
= CURSOR_MOVEMENT_SUCCESS
;
15361 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
15363 rc
= CURSOR_MOVEMENT_SUCCESS
;
15368 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
15369 && MATRIX_ROW_START_CHARPOS (row
) == PT
15370 && cursor_row_p (row
));
15378 #if !defined USE_TOOLKIT_SCROLL_BARS || defined USE_GTK
15382 set_vertical_scroll_bar (struct window
*w
)
15384 ptrdiff_t start
, end
, whole
;
15386 /* Calculate the start and end positions for the current window.
15387 At some point, it would be nice to choose between scrollbars
15388 which reflect the whole buffer size, with special markers
15389 indicating narrowing, and scrollbars which reflect only the
15392 Note that mini-buffers sometimes aren't displaying any text. */
15393 if (!MINI_WINDOW_P (w
)
15394 || (w
== XWINDOW (minibuf_window
)
15395 && NILP (echo_area_buffer
[0])))
15397 struct buffer
*buf
= XBUFFER (w
->buffer
);
15398 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
15399 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
15400 /* I don't think this is guaranteed to be right. For the
15401 moment, we'll pretend it is. */
15402 end
= BUF_Z (buf
) - XFASTINT (w
->window_end_pos
) - BUF_BEGV (buf
);
15406 if (whole
< (end
- start
))
15407 whole
= end
- start
;
15410 start
= end
= whole
= 0;
15412 /* Indicate what this scroll bar ought to be displaying now. */
15413 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15414 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
15415 (w
, end
- start
, whole
, start
);
15419 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
15420 selected_window is redisplayed.
15422 We can return without actually redisplaying the window if
15423 fonts_changed_p. In that case, redisplay_internal will
15427 redisplay_window (Lisp_Object window
, int just_this_one_p
)
15429 struct window
*w
= XWINDOW (window
);
15430 struct frame
*f
= XFRAME (w
->frame
);
15431 struct buffer
*buffer
= XBUFFER (w
->buffer
);
15432 struct buffer
*old
= current_buffer
;
15433 struct text_pos lpoint
, opoint
, startp
;
15434 int update_mode_line
;
15437 /* Record it now because it's overwritten. */
15438 int current_matrix_up_to_date_p
= 0;
15439 int used_current_matrix_p
= 0;
15440 /* This is less strict than current_matrix_up_to_date_p.
15441 It indicates that the buffer contents and narrowing are unchanged. */
15442 int buffer_unchanged_p
= 0;
15443 int temp_scroll_step
= 0;
15444 ptrdiff_t count
= SPECPDL_INDEX ();
15446 int centering_position
= -1;
15447 int last_line_misfit
= 0;
15448 ptrdiff_t beg_unchanged
, end_unchanged
;
15450 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
15453 /* W must be a leaf window here. */
15454 eassert (!NILP (w
->buffer
));
15456 *w
->desired_matrix
->method
= 0;
15460 reconsider_clip_changes (w
, buffer
);
15462 /* Has the mode line to be updated? */
15463 update_mode_line
= (w
->update_mode_line
15464 || update_mode_lines
15465 || buffer
->clip_changed
15466 || buffer
->prevent_redisplay_optimizations_p
);
15468 if (MINI_WINDOW_P (w
))
15470 if (w
== XWINDOW (echo_area_window
)
15471 && !NILP (echo_area_buffer
[0]))
15473 if (update_mode_line
)
15474 /* We may have to update a tty frame's menu bar or a
15475 tool-bar. Example `M-x C-h C-h C-g'. */
15476 goto finish_menu_bars
;
15478 /* We've already displayed the echo area glyphs in this window. */
15479 goto finish_scroll_bars
;
15481 else if ((w
!= XWINDOW (minibuf_window
)
15482 || minibuf_level
== 0)
15483 /* When buffer is nonempty, redisplay window normally. */
15484 && BUF_Z (XBUFFER (w
->buffer
)) == BUF_BEG (XBUFFER (w
->buffer
))
15485 /* Quail displays non-mini buffers in minibuffer window.
15486 In that case, redisplay the window normally. */
15487 && !NILP (Fmemq (w
->buffer
, Vminibuffer_list
)))
15489 /* W is a mini-buffer window, but it's not active, so clear
15491 int yb
= window_text_bottom_y (w
);
15492 struct glyph_row
*row
;
15495 for (y
= 0, row
= w
->desired_matrix
->rows
;
15497 y
+= row
->height
, ++row
)
15498 blank_row (w
, row
, y
);
15499 goto finish_scroll_bars
;
15502 clear_glyph_matrix (w
->desired_matrix
);
15505 /* Otherwise set up data on this window; select its buffer and point
15507 /* Really select the buffer, for the sake of buffer-local
15509 set_buffer_internal_1 (XBUFFER (w
->buffer
));
15511 current_matrix_up_to_date_p
15512 = (!NILP (w
->window_end_valid
)
15513 && !current_buffer
->clip_changed
15514 && !current_buffer
->prevent_redisplay_optimizations_p
15515 && !window_outdated (w
));
15517 /* Run the window-bottom-change-functions
15518 if it is possible that the text on the screen has changed
15519 (either due to modification of the text, or any other reason). */
15520 if (!current_matrix_up_to_date_p
15521 && !NILP (Vwindow_text_change_functions
))
15523 safe_run_hooks (Qwindow_text_change_functions
);
15527 beg_unchanged
= BEG_UNCHANGED
;
15528 end_unchanged
= END_UNCHANGED
;
15530 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
15532 specbind (Qinhibit_point_motion_hooks
, Qt
);
15535 = (!NILP (w
->window_end_valid
)
15536 && !current_buffer
->clip_changed
15537 && !window_outdated (w
));
15539 /* When windows_or_buffers_changed is non-zero, we can't rely on
15540 the window end being valid, so set it to nil there. */
15541 if (windows_or_buffers_changed
)
15543 /* If window starts on a continuation line, maybe adjust the
15544 window start in case the window's width changed. */
15545 if (XMARKER (w
->start
)->buffer
== current_buffer
)
15546 compute_window_start_on_continuation_line (w
);
15548 wset_window_end_valid (w
, Qnil
);
15551 /* Some sanity checks. */
15552 CHECK_WINDOW_END (w
);
15553 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
15555 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
15558 if (mode_line_update_needed (w
))
15559 update_mode_line
= 1;
15561 /* Point refers normally to the selected window. For any other
15562 window, set up appropriate value. */
15563 if (!EQ (window
, selected_window
))
15565 ptrdiff_t new_pt
= XMARKER (w
->pointm
)->charpos
;
15566 ptrdiff_t new_pt_byte
= marker_byte_position (w
->pointm
);
15570 new_pt_byte
= BEGV_BYTE
;
15571 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
15573 else if (new_pt
> (ZV
- 1))
15576 new_pt_byte
= ZV_BYTE
;
15577 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
15580 /* We don't use SET_PT so that the point-motion hooks don't run. */
15581 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
15584 /* If any of the character widths specified in the display table
15585 have changed, invalidate the width run cache. It's true that
15586 this may be a bit late to catch such changes, but the rest of
15587 redisplay goes (non-fatally) haywire when the display table is
15588 changed, so why should we worry about doing any better? */
15589 if (current_buffer
->width_run_cache
)
15591 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
15593 if (! disptab_matches_widthtab
15594 (disptab
, XVECTOR (BVAR (current_buffer
, width_table
))))
15596 invalidate_region_cache (current_buffer
,
15597 current_buffer
->width_run_cache
,
15599 recompute_width_table (current_buffer
, disptab
);
15603 /* If window-start is screwed up, choose a new one. */
15604 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
15607 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15609 /* If someone specified a new starting point but did not insist,
15610 check whether it can be used. */
15611 if (w
->optional_new_start
15612 && CHARPOS (startp
) >= BEGV
15613 && CHARPOS (startp
) <= ZV
)
15615 w
->optional_new_start
= 0;
15616 start_display (&it
, w
, startp
);
15617 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
15618 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
15619 if (IT_CHARPOS (it
) == PT
)
15620 w
->force_start
= 1;
15621 /* IT may overshoot PT if text at PT is invisible. */
15622 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
15623 w
->force_start
= 1;
15628 /* Handle case where place to start displaying has been specified,
15629 unless the specified location is outside the accessible range. */
15630 if (w
->force_start
|| w
->frozen_window_start_p
)
15632 /* We set this later on if we have to adjust point. */
15635 w
->force_start
= 0;
15637 wset_window_end_valid (w
, Qnil
);
15639 /* Forget any recorded base line for line number display. */
15640 if (!buffer_unchanged_p
)
15641 wset_base_line_number (w
, Qnil
);
15643 /* Redisplay the mode line. Select the buffer properly for that.
15644 Also, run the hook window-scroll-functions
15645 because we have scrolled. */
15646 /* Note, we do this after clearing force_start because
15647 if there's an error, it is better to forget about force_start
15648 than to get into an infinite loop calling the hook functions
15649 and having them get more errors. */
15650 if (!update_mode_line
15651 || ! NILP (Vwindow_scroll_functions
))
15653 update_mode_line
= 1;
15654 w
->update_mode_line
= 1;
15655 startp
= run_window_scroll_functions (window
, startp
);
15658 w
->last_modified
= 0;
15659 w
->last_overlay_modified
= 0;
15660 if (CHARPOS (startp
) < BEGV
)
15661 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
15662 else if (CHARPOS (startp
) > ZV
)
15663 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
15665 /* Redisplay, then check if cursor has been set during the
15666 redisplay. Give up if new fonts were loaded. */
15667 /* We used to issue a CHECK_MARGINS argument to try_window here,
15668 but this causes scrolling to fail when point begins inside
15669 the scroll margin (bug#148) -- cyd */
15670 if (!try_window (window
, startp
, 0))
15672 w
->force_start
= 1;
15673 clear_glyph_matrix (w
->desired_matrix
);
15674 goto need_larger_matrices
;
15677 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
15679 /* If point does not appear, try to move point so it does
15680 appear. The desired matrix has been built above, so we
15681 can use it here. */
15682 new_vpos
= window_box_height (w
) / 2;
15685 if (!cursor_row_fully_visible_p (w
, 0, 0))
15687 /* Point does appear, but on a line partly visible at end of window.
15688 Move it back to a fully-visible line. */
15689 new_vpos
= window_box_height (w
);
15691 else if (w
->cursor
.vpos
>=0)
15693 /* Some people insist on not letting point enter the scroll
15694 margin, even though this part handles windows that didn't
15696 struct frame
*f
= XFRAME (w
->frame
);
15697 int margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15698 int pixel_margin
= margin
* FRAME_LINE_HEIGHT (f
);
15699 bool header_line
= WINDOW_WANTS_HEADER_LINE_P (w
);
15701 /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
15702 below, which finds the row to move point to, advances by
15703 the Y coordinate of the _next_ row, see the definition of
15704 MATRIX_ROW_BOTTOM_Y. */
15705 if (w
->cursor
.vpos
< margin
+ header_line
)
15707 = pixel_margin
+ (header_line
15708 ? CURRENT_HEADER_LINE_HEIGHT (w
)
15709 : 0) + FRAME_LINE_HEIGHT (f
);
15712 int window_height
= window_box_height (w
);
15715 window_height
+= CURRENT_HEADER_LINE_HEIGHT (w
);
15716 if (w
->cursor
.y
>= window_height
- pixel_margin
)
15717 new_vpos
= window_height
- pixel_margin
;
15721 /* If we need to move point for either of the above reasons,
15722 now actually do it. */
15725 struct glyph_row
*row
;
15727 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
15728 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
15731 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
15732 MATRIX_ROW_START_BYTEPOS (row
));
15734 if (w
!= XWINDOW (selected_window
))
15735 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
15736 else if (current_buffer
== old
)
15737 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
15739 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
15741 /* If we are highlighting the region, then we just changed
15742 the region, so redisplay to show it. */
15743 if (!NILP (Vtransient_mark_mode
)
15744 && !NILP (BVAR (current_buffer
, mark_active
)))
15746 clear_glyph_matrix (w
->desired_matrix
);
15747 if (!try_window (window
, startp
, 0))
15748 goto need_larger_matrices
;
15753 debug_method_add (w
, "forced window start");
15758 /* Handle case where text has not changed, only point, and it has
15759 not moved off the frame, and we are not retrying after hscroll.
15760 (current_matrix_up_to_date_p is nonzero when retrying.) */
15761 if (current_matrix_up_to_date_p
15762 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
15763 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
15767 case CURSOR_MOVEMENT_SUCCESS
:
15768 used_current_matrix_p
= 1;
15771 case CURSOR_MOVEMENT_MUST_SCROLL
:
15772 goto try_to_scroll
;
15778 /* If current starting point was originally the beginning of a line
15779 but no longer is, find a new starting point. */
15780 else if (w
->start_at_line_beg
15781 && !(CHARPOS (startp
) <= BEGV
15782 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
15785 debug_method_add (w
, "recenter 1");
15790 /* Try scrolling with try_window_id. Value is > 0 if update has
15791 been done, it is -1 if we know that the same window start will
15792 not work. It is 0 if unsuccessful for some other reason. */
15793 else if ((tem
= try_window_id (w
)) != 0)
15796 debug_method_add (w
, "try_window_id %d", tem
);
15799 if (fonts_changed_p
)
15800 goto need_larger_matrices
;
15804 /* Otherwise try_window_id has returned -1 which means that we
15805 don't want the alternative below this comment to execute. */
15807 else if (CHARPOS (startp
) >= BEGV
15808 && CHARPOS (startp
) <= ZV
15809 && PT
>= CHARPOS (startp
)
15810 && (CHARPOS (startp
) < ZV
15811 /* Avoid starting at end of buffer. */
15812 || CHARPOS (startp
) == BEGV
15813 || !window_outdated (w
)))
15815 int d1
, d2
, d3
, d4
, d5
, d6
;
15817 /* If first window line is a continuation line, and window start
15818 is inside the modified region, but the first change is before
15819 current window start, we must select a new window start.
15821 However, if this is the result of a down-mouse event (e.g. by
15822 extending the mouse-drag-overlay), we don't want to select a
15823 new window start, since that would change the position under
15824 the mouse, resulting in an unwanted mouse-movement rather
15825 than a simple mouse-click. */
15826 if (!w
->start_at_line_beg
15827 && NILP (do_mouse_tracking
)
15828 && CHARPOS (startp
) > BEGV
15829 && CHARPOS (startp
) > BEG
+ beg_unchanged
15830 && CHARPOS (startp
) <= Z
- end_unchanged
15831 /* Even if w->start_at_line_beg is nil, a new window may
15832 start at a line_beg, since that's how set_buffer_window
15833 sets it. So, we need to check the return value of
15834 compute_window_start_on_continuation_line. (See also
15836 && XMARKER (w
->start
)->buffer
== current_buffer
15837 && compute_window_start_on_continuation_line (w
)
15838 /* It doesn't make sense to force the window start like we
15839 do at label force_start if it is already known that point
15840 will not be visible in the resulting window, because
15841 doing so will move point from its correct position
15842 instead of scrolling the window to bring point into view.
15844 && pos_visible_p (w
, PT
, &d1
, &d2
, &d3
, &d4
, &d5
, &d6
))
15846 w
->force_start
= 1;
15847 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15852 debug_method_add (w
, "same window start");
15855 /* Try to redisplay starting at same place as before.
15856 If point has not moved off frame, accept the results. */
15857 if (!current_matrix_up_to_date_p
15858 /* Don't use try_window_reusing_current_matrix in this case
15859 because a window scroll function can have changed the
15861 || !NILP (Vwindow_scroll_functions
)
15862 || MINI_WINDOW_P (w
)
15863 || !(used_current_matrix_p
15864 = try_window_reusing_current_matrix (w
)))
15866 IF_DEBUG (debug_method_add (w
, "1"));
15867 if (try_window (window
, startp
, TRY_WINDOW_CHECK_MARGINS
) < 0)
15868 /* -1 means we need to scroll.
15869 0 means we need new matrices, but fonts_changed_p
15870 is set in that case, so we will detect it below. */
15871 goto try_to_scroll
;
15874 if (fonts_changed_p
)
15875 goto need_larger_matrices
;
15877 if (w
->cursor
.vpos
>= 0)
15879 if (!just_this_one_p
15880 || current_buffer
->clip_changed
15881 || BEG_UNCHANGED
< CHARPOS (startp
))
15882 /* Forget any recorded base line for line number display. */
15883 wset_base_line_number (w
, Qnil
);
15885 if (!cursor_row_fully_visible_p (w
, 1, 0))
15887 clear_glyph_matrix (w
->desired_matrix
);
15888 last_line_misfit
= 1;
15890 /* Drop through and scroll. */
15895 clear_glyph_matrix (w
->desired_matrix
);
15900 w
->last_modified
= 0;
15901 w
->last_overlay_modified
= 0;
15903 /* Redisplay the mode line. Select the buffer properly for that. */
15904 if (!update_mode_line
)
15906 update_mode_line
= 1;
15907 w
->update_mode_line
= 1;
15910 /* Try to scroll by specified few lines. */
15911 if ((scroll_conservatively
15912 || emacs_scroll_step
15913 || temp_scroll_step
15914 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
))
15915 || NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
)))
15916 && CHARPOS (startp
) >= BEGV
15917 && CHARPOS (startp
) <= ZV
)
15919 /* The function returns -1 if new fonts were loaded, 1 if
15920 successful, 0 if not successful. */
15921 int ss
= try_scrolling (window
, just_this_one_p
,
15922 scroll_conservatively
,
15924 temp_scroll_step
, last_line_misfit
);
15927 case SCROLLING_SUCCESS
:
15930 case SCROLLING_NEED_LARGER_MATRICES
:
15931 goto need_larger_matrices
;
15933 case SCROLLING_FAILED
:
15941 /* Finally, just choose a place to start which positions point
15942 according to user preferences. */
15947 debug_method_add (w
, "recenter");
15950 /* w->vscroll = 0; */
15952 /* Forget any previously recorded base line for line number display. */
15953 if (!buffer_unchanged_p
)
15954 wset_base_line_number (w
, Qnil
);
15956 /* Determine the window start relative to point. */
15957 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
15958 it
.current_y
= it
.last_visible_y
;
15959 if (centering_position
< 0)
15963 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
15965 ptrdiff_t margin_pos
= CHARPOS (startp
);
15966 Lisp_Object aggressive
;
15969 /* If there is a scroll margin at the top of the window, find
15970 its character position. */
15972 /* Cannot call start_display if startp is not in the
15973 accessible region of the buffer. This can happen when we
15974 have just switched to a different buffer and/or changed
15975 its restriction. In that case, startp is initialized to
15976 the character position 1 (BEGV) because we did not yet
15977 have chance to display the buffer even once. */
15978 && BEGV
<= CHARPOS (startp
) && CHARPOS (startp
) <= ZV
)
15981 void *it1data
= NULL
;
15983 SAVE_IT (it1
, it
, it1data
);
15984 start_display (&it1
, w
, startp
);
15985 move_it_vertically (&it1
, margin
* FRAME_LINE_HEIGHT (f
));
15986 margin_pos
= IT_CHARPOS (it1
);
15987 RESTORE_IT (&it
, &it
, it1data
);
15989 scrolling_up
= PT
> margin_pos
;
15992 ? BVAR (current_buffer
, scroll_up_aggressively
)
15993 : BVAR (current_buffer
, scroll_down_aggressively
);
15995 if (!MINI_WINDOW_P (w
)
15996 && (scroll_conservatively
> SCROLL_LIMIT
|| NUMBERP (aggressive
)))
16000 /* Setting scroll-conservatively overrides
16001 scroll-*-aggressively. */
16002 if (!scroll_conservatively
&& NUMBERP (aggressive
))
16004 double float_amount
= XFLOATINT (aggressive
);
16006 pt_offset
= float_amount
* WINDOW_BOX_TEXT_HEIGHT (w
);
16007 if (pt_offset
== 0 && float_amount
> 0)
16009 if (pt_offset
&& margin
> 0)
16012 /* Compute how much to move the window start backward from
16013 point so that point will be displayed where the user
16017 centering_position
= it
.last_visible_y
;
16019 centering_position
-= pt_offset
;
16020 centering_position
-=
16021 FRAME_LINE_HEIGHT (f
) * (1 + margin
+ (last_line_misfit
!= 0))
16022 + WINDOW_HEADER_LINE_HEIGHT (w
);
16023 /* Don't let point enter the scroll margin near top of
16025 if (centering_position
< margin
* FRAME_LINE_HEIGHT (f
))
16026 centering_position
= margin
* FRAME_LINE_HEIGHT (f
);
16029 centering_position
= margin
* FRAME_LINE_HEIGHT (f
) + pt_offset
;
16032 /* Set the window start half the height of the window backward
16034 centering_position
= window_box_height (w
) / 2;
16036 move_it_vertically_backward (&it
, centering_position
);
16038 eassert (IT_CHARPOS (it
) >= BEGV
);
16040 /* The function move_it_vertically_backward may move over more
16041 than the specified y-distance. If it->w is small, e.g. a
16042 mini-buffer window, we may end up in front of the window's
16043 display area. Start displaying at the start of the line
16044 containing PT in this case. */
16045 if (it
.current_y
<= 0)
16047 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
16048 move_it_vertically_backward (&it
, 0);
16052 it
.current_x
= it
.hpos
= 0;
16054 /* Set the window start position here explicitly, to avoid an
16055 infinite loop in case the functions in window-scroll-functions
16057 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
16059 /* Run scroll hooks. */
16060 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
16062 /* Redisplay the window. */
16063 if (!current_matrix_up_to_date_p
16064 || windows_or_buffers_changed
16065 || cursor_type_changed
16066 /* Don't use try_window_reusing_current_matrix in this case
16067 because it can have changed the buffer. */
16068 || !NILP (Vwindow_scroll_functions
)
16069 || !just_this_one_p
16070 || MINI_WINDOW_P (w
)
16071 || !(used_current_matrix_p
16072 = try_window_reusing_current_matrix (w
)))
16073 try_window (window
, startp
, 0);
16075 /* If new fonts have been loaded (due to fontsets), give up. We
16076 have to start a new redisplay since we need to re-adjust glyph
16078 if (fonts_changed_p
)
16079 goto need_larger_matrices
;
16081 /* If cursor did not appear assume that the middle of the window is
16082 in the first line of the window. Do it again with the next line.
16083 (Imagine a window of height 100, displaying two lines of height
16084 60. Moving back 50 from it->last_visible_y will end in the first
16086 if (w
->cursor
.vpos
< 0)
16088 if (!NILP (w
->window_end_valid
)
16089 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
16091 clear_glyph_matrix (w
->desired_matrix
);
16092 move_it_by_lines (&it
, 1);
16093 try_window (window
, it
.current
.pos
, 0);
16095 else if (PT
< IT_CHARPOS (it
))
16097 clear_glyph_matrix (w
->desired_matrix
);
16098 move_it_by_lines (&it
, -1);
16099 try_window (window
, it
.current
.pos
, 0);
16103 /* Not much we can do about it. */
16107 /* Consider the following case: Window starts at BEGV, there is
16108 invisible, intangible text at BEGV, so that display starts at
16109 some point START > BEGV. It can happen that we are called with
16110 PT somewhere between BEGV and START. Try to handle that case. */
16111 if (w
->cursor
.vpos
< 0)
16113 struct glyph_row
*row
= w
->current_matrix
->rows
;
16114 if (row
->mode_line_p
)
16116 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
16119 if (!cursor_row_fully_visible_p (w
, 0, 0))
16121 /* If vscroll is enabled, disable it and try again. */
16125 clear_glyph_matrix (w
->desired_matrix
);
16129 /* Users who set scroll-conservatively to a large number want
16130 point just above/below the scroll margin. If we ended up
16131 with point's row partially visible, move the window start to
16132 make that row fully visible and out of the margin. */
16133 if (scroll_conservatively
> SCROLL_LIMIT
)
16137 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
16139 int move_down
= w
->cursor
.vpos
>= WINDOW_TOTAL_LINES (w
) / 2;
16141 move_it_by_lines (&it
, move_down
? margin
+ 1 : -(margin
+ 1));
16142 clear_glyph_matrix (w
->desired_matrix
);
16143 if (1 == try_window (window
, it
.current
.pos
,
16144 TRY_WINDOW_CHECK_MARGINS
))
16148 /* If centering point failed to make the whole line visible,
16149 put point at the top instead. That has to make the whole line
16150 visible, if it can be done. */
16151 if (centering_position
== 0)
16154 clear_glyph_matrix (w
->desired_matrix
);
16155 centering_position
= 0;
16161 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
16162 w
->start_at_line_beg
= (CHARPOS (startp
) == BEGV
16163 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n');
16165 /* Display the mode line, if we must. */
16166 if ((update_mode_line
16167 /* If window not full width, must redo its mode line
16168 if (a) the window to its side is being redone and
16169 (b) we do a frame-based redisplay. This is a consequence
16170 of how inverted lines are drawn in frame-based redisplay. */
16171 || (!just_this_one_p
16172 && !FRAME_WINDOW_P (f
)
16173 && !WINDOW_FULL_WIDTH_P (w
))
16174 /* Line number to display. */
16175 || INTEGERP (w
->base_line_pos
)
16176 /* Column number is displayed and different from the one displayed. */
16177 || (!NILP (w
->column_number_displayed
)
16178 && (XFASTINT (w
->column_number_displayed
) != current_column ())))
16179 /* This means that the window has a mode line. */
16180 && (WINDOW_WANTS_MODELINE_P (w
)
16181 || WINDOW_WANTS_HEADER_LINE_P (w
)))
16183 display_mode_lines (w
);
16185 /* If mode line height has changed, arrange for a thorough
16186 immediate redisplay using the correct mode line height. */
16187 if (WINDOW_WANTS_MODELINE_P (w
)
16188 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
16190 fonts_changed_p
= 1;
16191 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
16192 = DESIRED_MODE_LINE_HEIGHT (w
);
16195 /* If header line height has changed, arrange for a thorough
16196 immediate redisplay using the correct header line height. */
16197 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16198 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
16200 fonts_changed_p
= 1;
16201 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
16202 = DESIRED_HEADER_LINE_HEIGHT (w
);
16205 if (fonts_changed_p
)
16206 goto need_larger_matrices
;
16209 if (!line_number_displayed
16210 && !BUFFERP (w
->base_line_pos
))
16212 wset_base_line_pos (w
, Qnil
);
16213 wset_base_line_number (w
, Qnil
);
16218 /* When we reach a frame's selected window, redo the frame's menu bar. */
16219 if (update_mode_line
16220 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
16222 int redisplay_menu_p
= 0;
16224 if (FRAME_WINDOW_P (f
))
16226 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
16227 || defined (HAVE_NS) || defined (USE_GTK)
16228 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
16230 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16234 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
16236 if (redisplay_menu_p
)
16237 display_menu_bar (w
);
16239 #ifdef HAVE_WINDOW_SYSTEM
16240 if (FRAME_WINDOW_P (f
))
16242 #if defined (USE_GTK) || defined (HAVE_NS)
16243 if (FRAME_EXTERNAL_TOOL_BAR (f
))
16244 redisplay_tool_bar (f
);
16246 if (WINDOWP (f
->tool_bar_window
)
16247 && (FRAME_TOOL_BAR_LINES (f
) > 0
16248 || !NILP (Vauto_resize_tool_bars
))
16249 && redisplay_tool_bar (f
))
16250 ignore_mouse_drag_p
= 1;
16256 #ifdef HAVE_WINDOW_SYSTEM
16257 if (FRAME_WINDOW_P (f
)
16258 && update_window_fringes (w
, (just_this_one_p
16259 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
16260 || w
->pseudo_window_p
)))
16264 if (draw_window_fringes (w
, 1))
16265 x_draw_vertical_border (w
);
16269 #endif /* HAVE_WINDOW_SYSTEM */
16271 /* We go to this label, with fonts_changed_p set,
16272 if it is necessary to try again using larger glyph matrices.
16273 We have to redeem the scroll bar even in this case,
16274 because the loop in redisplay_internal expects that. */
16275 need_larger_matrices
:
16277 finish_scroll_bars
:
16279 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
16281 /* Set the thumb's position and size. */
16282 set_vertical_scroll_bar (w
);
16284 /* Note that we actually used the scroll bar attached to this
16285 window, so it shouldn't be deleted at the end of redisplay. */
16286 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
16287 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
16290 /* Restore current_buffer and value of point in it. The window
16291 update may have changed the buffer, so first make sure `opoint'
16292 is still valid (Bug#6177). */
16293 if (CHARPOS (opoint
) < BEGV
)
16294 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
16295 else if (CHARPOS (opoint
) > ZV
)
16296 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
16298 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
16300 set_buffer_internal_1 (old
);
16301 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
16302 shorter. This can be caused by log truncation in *Messages*. */
16303 if (CHARPOS (lpoint
) <= ZV
)
16304 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
16306 unbind_to (count
, Qnil
);
16310 /* Build the complete desired matrix of WINDOW with a window start
16311 buffer position POS.
16313 Value is 1 if successful. It is zero if fonts were loaded during
16314 redisplay which makes re-adjusting glyph matrices necessary, and -1
16315 if point would appear in the scroll margins.
16316 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
16317 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
16321 try_window (Lisp_Object window
, struct text_pos pos
, int flags
)
16323 struct window
*w
= XWINDOW (window
);
16325 struct glyph_row
*last_text_row
= NULL
;
16326 struct frame
*f
= XFRAME (w
->frame
);
16328 /* Make POS the new window start. */
16329 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
16331 /* Mark cursor position as unknown. No overlay arrow seen. */
16332 w
->cursor
.vpos
= -1;
16333 overlay_arrow_seen
= 0;
16335 /* Initialize iterator and info to start at POS. */
16336 start_display (&it
, w
, pos
);
16338 /* Display all lines of W. */
16339 while (it
.current_y
< it
.last_visible_y
)
16341 if (display_line (&it
))
16342 last_text_row
= it
.glyph_row
- 1;
16343 if (fonts_changed_p
&& !(flags
& TRY_WINDOW_IGNORE_FONTS_CHANGE
))
16347 /* Don't let the cursor end in the scroll margins. */
16348 if ((flags
& TRY_WINDOW_CHECK_MARGINS
)
16349 && !MINI_WINDOW_P (w
))
16351 int this_scroll_margin
;
16353 if (scroll_margin
> 0)
16355 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
16356 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
16359 this_scroll_margin
= 0;
16361 if ((w
->cursor
.y
>= 0 /* not vscrolled */
16362 && w
->cursor
.y
< this_scroll_margin
16363 && CHARPOS (pos
) > BEGV
16364 && IT_CHARPOS (it
) < ZV
)
16365 /* rms: considering make_cursor_line_fully_visible_p here
16366 seems to give wrong results. We don't want to recenter
16367 when the last line is partly visible, we want to allow
16368 that case to be handled in the usual way. */
16369 || w
->cursor
.y
> it
.last_visible_y
- this_scroll_margin
- 1)
16371 w
->cursor
.vpos
= -1;
16372 clear_glyph_matrix (w
->desired_matrix
);
16377 /* If bottom moved off end of frame, change mode line percentage. */
16378 if (XFASTINT (w
->window_end_pos
) <= 0
16379 && Z
!= IT_CHARPOS (it
))
16380 w
->update_mode_line
= 1;
16382 /* Set window_end_pos to the offset of the last character displayed
16383 on the window from the end of current_buffer. Set
16384 window_end_vpos to its row number. */
16387 eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
16388 w
->window_end_bytepos
16389 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16390 wset_window_end_pos
16391 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16392 wset_window_end_vpos
16393 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
)));
16395 (MATRIX_ROW (w
->desired_matrix
,
16396 XFASTINT (w
->window_end_vpos
))->displays_text_p
);
16400 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
16401 wset_window_end_pos (w
, make_number (Z
- ZV
));
16402 wset_window_end_vpos (w
, make_number (0));
16405 /* But that is not valid info until redisplay finishes. */
16406 wset_window_end_valid (w
, Qnil
);
16412 /************************************************************************
16413 Window redisplay reusing current matrix when buffer has not changed
16414 ************************************************************************/
16416 /* Try redisplay of window W showing an unchanged buffer with a
16417 different window start than the last time it was displayed by
16418 reusing its current matrix. Value is non-zero if successful.
16419 W->start is the new window start. */
16422 try_window_reusing_current_matrix (struct window
*w
)
16424 struct frame
*f
= XFRAME (w
->frame
);
16425 struct glyph_row
*bottom_row
;
16428 struct text_pos start
, new_start
;
16429 int nrows_scrolled
, i
;
16430 struct glyph_row
*last_text_row
;
16431 struct glyph_row
*last_reused_text_row
;
16432 struct glyph_row
*start_row
;
16433 int start_vpos
, min_y
, max_y
;
16436 if (inhibit_try_window_reusing
)
16440 if (/* This function doesn't handle terminal frames. */
16441 !FRAME_WINDOW_P (f
)
16442 /* Don't try to reuse the display if windows have been split
16444 || windows_or_buffers_changed
16445 || cursor_type_changed
)
16448 /* Can't do this if region may have changed. */
16449 if ((!NILP (Vtransient_mark_mode
)
16450 && !NILP (BVAR (current_buffer
, mark_active
)))
16451 || !NILP (w
->region_showing
)
16452 || !NILP (Vshow_trailing_whitespace
))
16455 /* If top-line visibility has changed, give up. */
16456 if (WINDOW_WANTS_HEADER_LINE_P (w
)
16457 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
16460 /* Give up if old or new display is scrolled vertically. We could
16461 make this function handle this, but right now it doesn't. */
16462 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16463 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
16466 /* The variable new_start now holds the new window start. The old
16467 start `start' can be determined from the current matrix. */
16468 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
16469 start
= start_row
->minpos
;
16470 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16472 /* Clear the desired matrix for the display below. */
16473 clear_glyph_matrix (w
->desired_matrix
);
16475 if (CHARPOS (new_start
) <= CHARPOS (start
))
16477 /* Don't use this method if the display starts with an ellipsis
16478 displayed for invisible text. It's not easy to handle that case
16479 below, and it's certainly not worth the effort since this is
16480 not a frequent case. */
16481 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
16484 IF_DEBUG (debug_method_add (w
, "twu1"));
16486 /* Display up to a row that can be reused. The variable
16487 last_text_row is set to the last row displayed that displays
16488 text. Note that it.vpos == 0 if or if not there is a
16489 header-line; it's not the same as the MATRIX_ROW_VPOS! */
16490 start_display (&it
, w
, new_start
);
16491 w
->cursor
.vpos
= -1;
16492 last_text_row
= last_reused_text_row
= NULL
;
16494 while (it
.current_y
< it
.last_visible_y
16495 && !fonts_changed_p
)
16497 /* If we have reached into the characters in the START row,
16498 that means the line boundaries have changed. So we
16499 can't start copying with the row START. Maybe it will
16500 work to start copying with the following row. */
16501 while (IT_CHARPOS (it
) > CHARPOS (start
))
16503 /* Advance to the next row as the "start". */
16505 start
= start_row
->minpos
;
16506 /* If there are no more rows to try, or just one, give up. */
16507 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
16508 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
16509 || CHARPOS (start
) == ZV
)
16511 clear_glyph_matrix (w
->desired_matrix
);
16515 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
16517 /* If we have reached alignment, we can copy the rest of the
16519 if (IT_CHARPOS (it
) == CHARPOS (start
)
16520 /* Don't accept "alignment" inside a display vector,
16521 since start_row could have started in the middle of
16522 that same display vector (thus their character
16523 positions match), and we have no way of telling if
16524 that is the case. */
16525 && it
.current
.dpvec_index
< 0)
16528 if (display_line (&it
))
16529 last_text_row
= it
.glyph_row
- 1;
16533 /* A value of current_y < last_visible_y means that we stopped
16534 at the previous window start, which in turn means that we
16535 have at least one reusable row. */
16536 if (it
.current_y
< it
.last_visible_y
)
16538 struct glyph_row
*row
;
16540 /* IT.vpos always starts from 0; it counts text lines. */
16541 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
16543 /* Find PT if not already found in the lines displayed. */
16544 if (w
->cursor
.vpos
< 0)
16546 int dy
= it
.current_y
- start_row
->y
;
16548 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16549 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
16551 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
16552 dy
, nrows_scrolled
);
16555 clear_glyph_matrix (w
->desired_matrix
);
16560 /* Scroll the display. Do it before the current matrix is
16561 changed. The problem here is that update has not yet
16562 run, i.e. part of the current matrix is not up to date.
16563 scroll_run_hook will clear the cursor, and use the
16564 current matrix to get the height of the row the cursor is
16566 run
.current_y
= start_row
->y
;
16567 run
.desired_y
= it
.current_y
;
16568 run
.height
= it
.last_visible_y
- it
.current_y
;
16570 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
16573 FRAME_RIF (f
)->update_window_begin_hook (w
);
16574 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16575 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16576 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16580 /* Shift current matrix down by nrows_scrolled lines. */
16581 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
16582 rotate_matrix (w
->current_matrix
,
16584 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
16587 /* Disable lines that must be updated. */
16588 for (i
= 0; i
< nrows_scrolled
; ++i
)
16589 (start_row
+ i
)->enabled_p
= 0;
16591 /* Re-compute Y positions. */
16592 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16593 max_y
= it
.last_visible_y
;
16594 for (row
= start_row
+ nrows_scrolled
;
16598 row
->y
= it
.current_y
;
16599 row
->visible_height
= row
->height
;
16601 if (row
->y
< min_y
)
16602 row
->visible_height
-= min_y
- row
->y
;
16603 if (row
->y
+ row
->height
> max_y
)
16604 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
16605 if (row
->fringe_bitmap_periodic_p
)
16606 row
->redraw_fringe_bitmaps_p
= 1;
16608 it
.current_y
+= row
->height
;
16610 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16611 last_reused_text_row
= row
;
16612 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
16616 /* Disable lines in the current matrix which are now
16617 below the window. */
16618 for (++row
; row
< bottom_row
; ++row
)
16619 row
->enabled_p
= row
->mode_line_p
= 0;
16622 /* Update window_end_pos etc.; last_reused_text_row is the last
16623 reused row from the current matrix containing text, if any.
16624 The value of last_text_row is the last displayed line
16625 containing text. */
16626 if (last_reused_text_row
)
16628 w
->window_end_bytepos
16629 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
16630 wset_window_end_pos
16632 - MATRIX_ROW_END_CHARPOS (last_reused_text_row
)));
16633 wset_window_end_vpos
16634 (w
, make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
16635 w
->current_matrix
)));
16637 else if (last_text_row
)
16639 w
->window_end_bytepos
16640 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16641 wset_window_end_pos
16642 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16643 wset_window_end_vpos
16644 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
,
16645 w
->desired_matrix
)));
16649 /* This window must be completely empty. */
16650 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
16651 wset_window_end_pos (w
, make_number (Z
- ZV
));
16652 wset_window_end_vpos (w
, make_number (0));
16654 wset_window_end_valid (w
, Qnil
);
16656 /* Update hint: don't try scrolling again in update_window. */
16657 w
->desired_matrix
->no_scrolling_p
= 1;
16660 debug_method_add (w
, "try_window_reusing_current_matrix 1");
16664 else if (CHARPOS (new_start
) > CHARPOS (start
))
16666 struct glyph_row
*pt_row
, *row
;
16667 struct glyph_row
*first_reusable_row
;
16668 struct glyph_row
*first_row_to_display
;
16670 int yb
= window_text_bottom_y (w
);
16672 /* Find the row starting at new_start, if there is one. Don't
16673 reuse a partially visible line at the end. */
16674 first_reusable_row
= start_row
;
16675 while (first_reusable_row
->enabled_p
16676 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
16677 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
16678 < CHARPOS (new_start
)))
16679 ++first_reusable_row
;
16681 /* Give up if there is no row to reuse. */
16682 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
16683 || !first_reusable_row
->enabled_p
16684 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
16685 != CHARPOS (new_start
)))
16688 /* We can reuse fully visible rows beginning with
16689 first_reusable_row to the end of the window. Set
16690 first_row_to_display to the first row that cannot be reused.
16691 Set pt_row to the row containing point, if there is any. */
16693 for (first_row_to_display
= first_reusable_row
;
16694 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
16695 ++first_row_to_display
)
16697 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
16698 && (PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
)
16699 || (PT
== MATRIX_ROW_END_CHARPOS (first_row_to_display
)
16700 && first_row_to_display
->ends_at_zv_p
16701 && pt_row
== NULL
)))
16702 pt_row
= first_row_to_display
;
16705 /* Start displaying at the start of first_row_to_display. */
16706 eassert (first_row_to_display
->y
< yb
);
16707 init_to_row_start (&it
, w
, first_row_to_display
);
16709 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
16711 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
16713 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
16714 + WINDOW_HEADER_LINE_HEIGHT (w
));
16716 /* Display lines beginning with first_row_to_display in the
16717 desired matrix. Set last_text_row to the last row displayed
16718 that displays text. */
16719 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
16720 if (pt_row
== NULL
)
16721 w
->cursor
.vpos
= -1;
16722 last_text_row
= NULL
;
16723 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
16724 if (display_line (&it
))
16725 last_text_row
= it
.glyph_row
- 1;
16727 /* If point is in a reused row, adjust y and vpos of the cursor
16731 w
->cursor
.vpos
-= nrows_scrolled
;
16732 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
16735 /* Give up if point isn't in a row displayed or reused. (This
16736 also handles the case where w->cursor.vpos < nrows_scrolled
16737 after the calls to display_line, which can happen with scroll
16738 margins. See bug#1295.) */
16739 if (w
->cursor
.vpos
< 0)
16741 clear_glyph_matrix (w
->desired_matrix
);
16745 /* Scroll the display. */
16746 run
.current_y
= first_reusable_row
->y
;
16747 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16748 run
.height
= it
.last_visible_y
- run
.current_y
;
16749 dy
= run
.current_y
- run
.desired_y
;
16754 FRAME_RIF (f
)->update_window_begin_hook (w
);
16755 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16756 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16757 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16761 /* Adjust Y positions of reused rows. */
16762 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
16763 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
16764 max_y
= it
.last_visible_y
;
16765 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
16768 row
->visible_height
= row
->height
;
16769 if (row
->y
< min_y
)
16770 row
->visible_height
-= min_y
- row
->y
;
16771 if (row
->y
+ row
->height
> max_y
)
16772 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
16773 if (row
->fringe_bitmap_periodic_p
)
16774 row
->redraw_fringe_bitmaps_p
= 1;
16777 /* Scroll the current matrix. */
16778 eassert (nrows_scrolled
> 0);
16779 rotate_matrix (w
->current_matrix
,
16781 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
16784 /* Disable rows not reused. */
16785 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
16786 row
->enabled_p
= 0;
16788 /* Point may have moved to a different line, so we cannot assume that
16789 the previous cursor position is valid; locate the correct row. */
16792 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
16794 && PT
>= MATRIX_ROW_END_CHARPOS (row
)
16795 && !row
->ends_at_zv_p
;
16799 w
->cursor
.y
= row
->y
;
16801 if (row
< bottom_row
)
16803 /* Can't simply scan the row for point with
16804 bidi-reordered glyph rows. Let set_cursor_from_row
16805 figure out where to put the cursor, and if it fails,
16807 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
16809 if (!set_cursor_from_row (w
, row
, w
->current_matrix
,
16812 clear_glyph_matrix (w
->desired_matrix
);
16818 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
16819 struct glyph
*end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
16822 && (!BUFFERP (glyph
->object
)
16823 || glyph
->charpos
< PT
);
16827 w
->cursor
.x
+= glyph
->pixel_width
;
16833 /* Adjust window end. A null value of last_text_row means that
16834 the window end is in reused rows which in turn means that
16835 only its vpos can have changed. */
16838 w
->window_end_bytepos
16839 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16840 wset_window_end_pos
16841 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
16842 wset_window_end_vpos
16843 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
,
16844 w
->desired_matrix
)));
16848 wset_window_end_vpos
16849 (w
, make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
));
16852 wset_window_end_valid (w
, Qnil
);
16853 w
->desired_matrix
->no_scrolling_p
= 1;
16856 debug_method_add (w
, "try_window_reusing_current_matrix 2");
16866 /************************************************************************
16867 Window redisplay reusing current matrix when buffer has changed
16868 ************************************************************************/
16870 static struct glyph_row
*find_last_unchanged_at_beg_row (struct window
*);
16871 static struct glyph_row
*find_first_unchanged_at_end_row (struct window
*,
16872 ptrdiff_t *, ptrdiff_t *);
16873 static struct glyph_row
*
16874 find_last_row_displaying_text (struct glyph_matrix
*, struct it
*,
16875 struct glyph_row
*);
16878 /* Return the last row in MATRIX displaying text. If row START is
16879 non-null, start searching with that row. IT gives the dimensions
16880 of the display. Value is null if matrix is empty; otherwise it is
16881 a pointer to the row found. */
16883 static struct glyph_row
*
16884 find_last_row_displaying_text (struct glyph_matrix
*matrix
, struct it
*it
,
16885 struct glyph_row
*start
)
16887 struct glyph_row
*row
, *row_found
;
16889 /* Set row_found to the last row in IT->w's current matrix
16890 displaying text. The loop looks funny but think of partially
16893 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
16894 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16896 eassert (row
->enabled_p
);
16898 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
16907 /* Return the last row in the current matrix of W that is not affected
16908 by changes at the start of current_buffer that occurred since W's
16909 current matrix was built. Value is null if no such row exists.
16911 BEG_UNCHANGED us the number of characters unchanged at the start of
16912 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
16913 first changed character in current_buffer. Characters at positions <
16914 BEG + BEG_UNCHANGED are at the same buffer positions as they were
16915 when the current matrix was built. */
16917 static struct glyph_row
*
16918 find_last_unchanged_at_beg_row (struct window
*w
)
16920 ptrdiff_t first_changed_pos
= BEG
+ BEG_UNCHANGED
;
16921 struct glyph_row
*row
;
16922 struct glyph_row
*row_found
= NULL
;
16923 int yb
= window_text_bottom_y (w
);
16925 /* Find the last row displaying unchanged text. */
16926 for (row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16927 MATRIX_ROW_DISPLAYS_TEXT_P (row
)
16928 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
;
16931 if (/* If row ends before first_changed_pos, it is unchanged,
16932 except in some case. */
16933 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
16934 /* When row ends in ZV and we write at ZV it is not
16936 && !row
->ends_at_zv_p
16937 /* When first_changed_pos is the end of a continued line,
16938 row is not unchanged because it may be no longer
16940 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
16941 && (row
->continued_p
16942 || row
->exact_window_width_line_p
))
16943 /* If ROW->end is beyond ZV, then ROW->end is outdated and
16944 needs to be recomputed, so don't consider this row as
16945 unchanged. This happens when the last line was
16946 bidi-reordered and was killed immediately before this
16947 redisplay cycle. In that case, ROW->end stores the
16948 buffer position of the first visual-order character of
16949 the killed text, which is now beyond ZV. */
16950 && CHARPOS (row
->end
.pos
) <= ZV
)
16953 /* Stop if last visible row. */
16954 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
16962 /* Find the first glyph row in the current matrix of W that is not
16963 affected by changes at the end of current_buffer since the
16964 time W's current matrix was built.
16966 Return in *DELTA the number of chars by which buffer positions in
16967 unchanged text at the end of current_buffer must be adjusted.
16969 Return in *DELTA_BYTES the corresponding number of bytes.
16971 Value is null if no such row exists, i.e. all rows are affected by
16974 static struct glyph_row
*
16975 find_first_unchanged_at_end_row (struct window
*w
,
16976 ptrdiff_t *delta
, ptrdiff_t *delta_bytes
)
16978 struct glyph_row
*row
;
16979 struct glyph_row
*row_found
= NULL
;
16981 *delta
= *delta_bytes
= 0;
16983 /* Display must not have been paused, otherwise the current matrix
16984 is not up to date. */
16985 eassert (!NILP (w
->window_end_valid
));
16987 /* A value of window_end_pos >= END_UNCHANGED means that the window
16988 end is in the range of changed text. If so, there is no
16989 unchanged row at the end of W's current matrix. */
16990 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
16993 /* Set row to the last row in W's current matrix displaying text. */
16994 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
16996 /* If matrix is entirely empty, no unchanged row exists. */
16997 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16999 /* The value of row is the last glyph row in the matrix having a
17000 meaningful buffer position in it. The end position of row
17001 corresponds to window_end_pos. This allows us to translate
17002 buffer positions in the current matrix to current buffer
17003 positions for characters not in changed text. */
17005 MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
17006 ptrdiff_t Z_BYTE_old
=
17007 MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17008 ptrdiff_t last_unchanged_pos
, last_unchanged_pos_old
;
17009 struct glyph_row
*first_text_row
17010 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
17012 *delta
= Z
- Z_old
;
17013 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17015 /* Set last_unchanged_pos to the buffer position of the last
17016 character in the buffer that has not been changed. Z is the
17017 index + 1 of the last character in current_buffer, i.e. by
17018 subtracting END_UNCHANGED we get the index of the last
17019 unchanged character, and we have to add BEG to get its buffer
17021 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
17022 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
17024 /* Search backward from ROW for a row displaying a line that
17025 starts at a minimum position >= last_unchanged_pos_old. */
17026 for (; row
> first_text_row
; --row
)
17028 /* This used to abort, but it can happen.
17029 It is ok to just stop the search instead here. KFS. */
17030 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
17033 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
17038 eassert (!row_found
|| MATRIX_ROW_DISPLAYS_TEXT_P (row_found
));
17044 /* Make sure that glyph rows in the current matrix of window W
17045 reference the same glyph memory as corresponding rows in the
17046 frame's frame matrix. This function is called after scrolling W's
17047 current matrix on a terminal frame in try_window_id and
17048 try_window_reusing_current_matrix. */
17051 sync_frame_with_window_matrix_rows (struct window
*w
)
17053 struct frame
*f
= XFRAME (w
->frame
);
17054 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
17056 /* Preconditions: W must be a leaf window and full-width. Its frame
17057 must have a frame matrix. */
17058 eassert (NILP (w
->hchild
) && NILP (w
->vchild
));
17059 eassert (WINDOW_FULL_WIDTH_P (w
));
17060 eassert (!FRAME_WINDOW_P (f
));
17062 /* If W is a full-width window, glyph pointers in W's current matrix
17063 have, by definition, to be the same as glyph pointers in the
17064 corresponding frame matrix. Note that frame matrices have no
17065 marginal areas (see build_frame_matrix). */
17066 window_row
= w
->current_matrix
->rows
;
17067 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
17068 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
17069 while (window_row
< window_row_end
)
17071 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
17072 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
17074 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
17075 frame_row
->glyphs
[TEXT_AREA
] = start
;
17076 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
17077 frame_row
->glyphs
[LAST_AREA
] = end
;
17079 /* Disable frame rows whose corresponding window rows have
17080 been disabled in try_window_id. */
17081 if (!window_row
->enabled_p
)
17082 frame_row
->enabled_p
= 0;
17084 ++window_row
, ++frame_row
;
17089 /* Find the glyph row in window W containing CHARPOS. Consider all
17090 rows between START and END (not inclusive). END null means search
17091 all rows to the end of the display area of W. Value is the row
17092 containing CHARPOS or null. */
17095 row_containing_pos (struct window
*w
, ptrdiff_t charpos
,
17096 struct glyph_row
*start
, struct glyph_row
*end
, int dy
)
17098 struct glyph_row
*row
= start
;
17099 struct glyph_row
*best_row
= NULL
;
17100 ptrdiff_t mindif
= BUF_ZV (XBUFFER (w
->buffer
)) + 1;
17103 /* If we happen to start on a header-line, skip that. */
17104 if (row
->mode_line_p
)
17107 if ((end
&& row
>= end
) || !row
->enabled_p
)
17110 last_y
= window_text_bottom_y (w
) - dy
;
17114 /* Give up if we have gone too far. */
17115 if (end
&& row
>= end
)
17117 /* This formerly returned if they were equal.
17118 I think that both quantities are of a "last plus one" type;
17119 if so, when they are equal, the row is within the screen. -- rms. */
17120 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
17123 /* If it is in this row, return this row. */
17124 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
17125 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
17126 /* The end position of a row equals the start
17127 position of the next row. If CHARPOS is there, we
17128 would rather display it in the next line, except
17129 when this line ends in ZV. */
17130 && !row
->ends_at_zv_p
17131 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
17132 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
17136 if (NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
17137 || (!best_row
&& !row
->continued_p
))
17139 /* In bidi-reordered rows, there could be several rows
17140 occluding point, all of them belonging to the same
17141 continued line. We need to find the row which fits
17142 CHARPOS the best. */
17143 for (g
= row
->glyphs
[TEXT_AREA
];
17144 g
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
17147 if (!STRINGP (g
->object
))
17149 if (g
->charpos
> 0 && eabs (g
->charpos
- charpos
) < mindif
)
17151 mindif
= eabs (g
->charpos
- charpos
);
17153 /* Exact match always wins. */
17160 else if (best_row
&& !row
->continued_p
)
17167 /* Try to redisplay window W by reusing its existing display. W's
17168 current matrix must be up to date when this function is called,
17169 i.e. window_end_valid must not be nil.
17173 1 if display has been updated
17174 0 if otherwise unsuccessful
17175 -1 if redisplay with same window start is known not to succeed
17177 The following steps are performed:
17179 1. Find the last row in the current matrix of W that is not
17180 affected by changes at the start of current_buffer. If no such row
17183 2. Find the first row in W's current matrix that is not affected by
17184 changes at the end of current_buffer. Maybe there is no such row.
17186 3. Display lines beginning with the row + 1 found in step 1 to the
17187 row found in step 2 or, if step 2 didn't find a row, to the end of
17190 4. If cursor is not known to appear on the window, give up.
17192 5. If display stopped at the row found in step 2, scroll the
17193 display and current matrix as needed.
17195 6. Maybe display some lines at the end of W, if we must. This can
17196 happen under various circumstances, like a partially visible line
17197 becoming fully visible, or because newly displayed lines are displayed
17198 in smaller font sizes.
17200 7. Update W's window end information. */
17203 try_window_id (struct window
*w
)
17205 struct frame
*f
= XFRAME (w
->frame
);
17206 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
17207 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
17208 struct glyph_row
*last_unchanged_at_beg_row
;
17209 struct glyph_row
*first_unchanged_at_end_row
;
17210 struct glyph_row
*row
;
17211 struct glyph_row
*bottom_row
;
17214 ptrdiff_t delta
= 0, delta_bytes
= 0, stop_pos
;
17216 struct text_pos start_pos
;
17218 int first_unchanged_at_end_vpos
= 0;
17219 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
17220 struct text_pos start
;
17221 ptrdiff_t first_changed_charpos
, last_changed_charpos
;
17224 if (inhibit_try_window_id
)
17228 /* This is handy for debugging. */
17230 #define GIVE_UP(X) \
17232 fprintf (stderr, "try_window_id give up %d\n", (X)); \
17236 #define GIVE_UP(X) return 0
17239 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
17241 /* Don't use this for mini-windows because these can show
17242 messages and mini-buffers, and we don't handle that here. */
17243 if (MINI_WINDOW_P (w
))
17246 /* This flag is used to prevent redisplay optimizations. */
17247 if (windows_or_buffers_changed
|| cursor_type_changed
)
17250 /* Verify that narrowing has not changed.
17251 Also verify that we were not told to prevent redisplay optimizations.
17252 It would be nice to further
17253 reduce the number of cases where this prevents try_window_id. */
17254 if (current_buffer
->clip_changed
17255 || current_buffer
->prevent_redisplay_optimizations_p
)
17258 /* Window must either use window-based redisplay or be full width. */
17259 if (!FRAME_WINDOW_P (f
)
17260 && (!FRAME_LINE_INS_DEL_OK (f
)
17261 || !WINDOW_FULL_WIDTH_P (w
)))
17264 /* Give up if point is known NOT to appear in W. */
17265 if (PT
< CHARPOS (start
))
17268 /* Another way to prevent redisplay optimizations. */
17269 if (w
->last_modified
== 0)
17272 /* Verify that window is not hscrolled. */
17273 if (w
->hscroll
!= 0)
17276 /* Verify that display wasn't paused. */
17277 if (NILP (w
->window_end_valid
))
17280 /* Can't use this if highlighting a region because a cursor movement
17281 will do more than just set the cursor. */
17282 if (!NILP (Vtransient_mark_mode
)
17283 && !NILP (BVAR (current_buffer
, mark_active
)))
17286 /* Likewise if highlighting trailing whitespace. */
17287 if (!NILP (Vshow_trailing_whitespace
))
17290 /* Likewise if showing a region. */
17291 if (!NILP (w
->region_showing
))
17294 /* Can't use this if overlay arrow position and/or string have
17296 if (overlay_arrows_changed_p ())
17299 /* When word-wrap is on, adding a space to the first word of a
17300 wrapped line can change the wrap position, altering the line
17301 above it. It might be worthwhile to handle this more
17302 intelligently, but for now just redisplay from scratch. */
17303 if (!NILP (BVAR (XBUFFER (w
->buffer
), word_wrap
)))
17306 /* Under bidi reordering, adding or deleting a character in the
17307 beginning of a paragraph, before the first strong directional
17308 character, can change the base direction of the paragraph (unless
17309 the buffer specifies a fixed paragraph direction), which will
17310 require to redisplay the whole paragraph. It might be worthwhile
17311 to find the paragraph limits and widen the range of redisplayed
17312 lines to that, but for now just give up this optimization and
17313 redisplay from scratch. */
17314 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
17315 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
17318 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
17319 only if buffer has really changed. The reason is that the gap is
17320 initially at Z for freshly visited files. The code below would
17321 set end_unchanged to 0 in that case. */
17322 if (MODIFF
> SAVE_MODIFF
17323 /* This seems to happen sometimes after saving a buffer. */
17324 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
17326 if (GPT
- BEG
< BEG_UNCHANGED
)
17327 BEG_UNCHANGED
= GPT
- BEG
;
17328 if (Z
- GPT
< END_UNCHANGED
)
17329 END_UNCHANGED
= Z
- GPT
;
17332 /* The position of the first and last character that has been changed. */
17333 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
17334 last_changed_charpos
= Z
- END_UNCHANGED
;
17336 /* If window starts after a line end, and the last change is in
17337 front of that newline, then changes don't affect the display.
17338 This case happens with stealth-fontification. Note that although
17339 the display is unchanged, glyph positions in the matrix have to
17340 be adjusted, of course. */
17341 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
17342 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
17343 && ((last_changed_charpos
< CHARPOS (start
)
17344 && CHARPOS (start
) == BEGV
)
17345 || (last_changed_charpos
< CHARPOS (start
) - 1
17346 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
17348 ptrdiff_t Z_old
, Z_delta
, Z_BYTE_old
, Z_delta_bytes
;
17349 struct glyph_row
*r0
;
17351 /* Compute how many chars/bytes have been added to or removed
17352 from the buffer. */
17353 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
17354 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
17355 Z_delta
= Z
- Z_old
;
17356 Z_delta_bytes
= Z_BYTE
- Z_BYTE_old
;
17358 /* Give up if PT is not in the window. Note that it already has
17359 been checked at the start of try_window_id that PT is not in
17360 front of the window start. */
17361 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + Z_delta
)
17364 /* If window start is unchanged, we can reuse the whole matrix
17365 as is, after adjusting glyph positions. No need to compute
17366 the window end again, since its offset from Z hasn't changed. */
17367 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17368 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + Z_delta
17369 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + Z_delta_bytes
17370 /* PT must not be in a partially visible line. */
17371 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + Z_delta
17372 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17374 /* Adjust positions in the glyph matrix. */
17375 if (Z_delta
|| Z_delta_bytes
)
17377 struct glyph_row
*r1
17378 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
17379 increment_matrix_positions (w
->current_matrix
,
17380 MATRIX_ROW_VPOS (r0
, current_matrix
),
17381 MATRIX_ROW_VPOS (r1
, current_matrix
),
17382 Z_delta
, Z_delta_bytes
);
17385 /* Set the cursor. */
17386 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17388 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17395 /* Handle the case that changes are all below what is displayed in
17396 the window, and that PT is in the window. This shortcut cannot
17397 be taken if ZV is visible in the window, and text has been added
17398 there that is visible in the window. */
17399 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
17400 /* ZV is not visible in the window, or there are no
17401 changes at ZV, actually. */
17402 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
17403 || first_changed_charpos
== last_changed_charpos
))
17405 struct glyph_row
*r0
;
17407 /* Give up if PT is not in the window. Note that it already has
17408 been checked at the start of try_window_id that PT is not in
17409 front of the window start. */
17410 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
17413 /* If window start is unchanged, we can reuse the whole matrix
17414 as is, without changing glyph positions since no text has
17415 been added/removed in front of the window end. */
17416 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17417 if (TEXT_POS_EQUAL_P (start
, r0
->minpos
)
17418 /* PT must not be in a partially visible line. */
17419 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
17420 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
17422 /* We have to compute the window end anew since text
17423 could have been added/removed after it. */
17424 wset_window_end_pos
17425 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17426 w
->window_end_bytepos
17427 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17429 /* Set the cursor. */
17430 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
17432 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
17439 /* Give up if window start is in the changed area.
17441 The condition used to read
17443 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
17445 but why that was tested escapes me at the moment. */
17446 if (CHARPOS (start
) >= first_changed_charpos
17447 && CHARPOS (start
) <= last_changed_charpos
)
17450 /* Check that window start agrees with the start of the first glyph
17451 row in its current matrix. Check this after we know the window
17452 start is not in changed text, otherwise positions would not be
17454 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
17455 if (!TEXT_POS_EQUAL_P (start
, row
->minpos
))
17458 /* Give up if the window ends in strings. Overlay strings
17459 at the end are difficult to handle, so don't try. */
17460 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
17461 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
17464 /* Compute the position at which we have to start displaying new
17465 lines. Some of the lines at the top of the window might be
17466 reusable because they are not displaying changed text. Find the
17467 last row in W's current matrix not affected by changes at the
17468 start of current_buffer. Value is null if changes start in the
17469 first line of window. */
17470 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
17471 if (last_unchanged_at_beg_row
)
17473 /* Avoid starting to display in the middle of a character, a TAB
17474 for instance. This is easier than to set up the iterator
17475 exactly, and it's not a frequent case, so the additional
17476 effort wouldn't really pay off. */
17477 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
17478 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
17479 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
17480 --last_unchanged_at_beg_row
;
17482 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
17485 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
17487 start_pos
= it
.current
.pos
;
17489 /* Start displaying new lines in the desired matrix at the same
17490 vpos we would use in the current matrix, i.e. below
17491 last_unchanged_at_beg_row. */
17492 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
17494 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
17495 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
17497 eassert (it
.hpos
== 0 && it
.current_x
== 0);
17501 /* There are no reusable lines at the start of the window.
17502 Start displaying in the first text line. */
17503 start_display (&it
, w
, start
);
17504 it
.vpos
= it
.first_vpos
;
17505 start_pos
= it
.current
.pos
;
17508 /* Find the first row that is not affected by changes at the end of
17509 the buffer. Value will be null if there is no unchanged row, in
17510 which case we must redisplay to the end of the window. delta
17511 will be set to the value by which buffer positions beginning with
17512 first_unchanged_at_end_row have to be adjusted due to text
17514 first_unchanged_at_end_row
17515 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
17516 IF_DEBUG (debug_delta
= delta
);
17517 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
17519 /* Set stop_pos to the buffer position up to which we will have to
17520 display new lines. If first_unchanged_at_end_row != NULL, this
17521 is the buffer position of the start of the line displayed in that
17522 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
17523 that we don't stop at a buffer position. */
17525 if (first_unchanged_at_end_row
)
17527 eassert (last_unchanged_at_beg_row
== NULL
17528 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
17530 /* If this is a continuation line, move forward to the next one
17531 that isn't. Changes in lines above affect this line.
17532 Caution: this may move first_unchanged_at_end_row to a row
17533 not displaying text. */
17534 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
17535 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17536 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17537 < it
.last_visible_y
))
17538 ++first_unchanged_at_end_row
;
17540 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
17541 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
17542 >= it
.last_visible_y
))
17543 first_unchanged_at_end_row
= NULL
;
17546 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
17548 first_unchanged_at_end_vpos
17549 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
17550 eassert (stop_pos
>= Z
- END_UNCHANGED
);
17553 else if (last_unchanged_at_beg_row
== NULL
)
17559 /* Either there is no unchanged row at the end, or the one we have
17560 now displays text. This is a necessary condition for the window
17561 end pos calculation at the end of this function. */
17562 eassert (first_unchanged_at_end_row
== NULL
17563 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
17565 debug_last_unchanged_at_beg_vpos
17566 = (last_unchanged_at_beg_row
17567 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
17569 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
17571 #endif /* GLYPH_DEBUG */
17574 /* Display new lines. Set last_text_row to the last new line
17575 displayed which has text on it, i.e. might end up as being the
17576 line where the window_end_vpos is. */
17577 w
->cursor
.vpos
= -1;
17578 last_text_row
= NULL
;
17579 overlay_arrow_seen
= 0;
17580 while (it
.current_y
< it
.last_visible_y
17581 && !fonts_changed_p
17582 && (first_unchanged_at_end_row
== NULL
17583 || IT_CHARPOS (it
) < stop_pos
))
17585 if (display_line (&it
))
17586 last_text_row
= it
.glyph_row
- 1;
17589 if (fonts_changed_p
)
17593 /* Compute differences in buffer positions, y-positions etc. for
17594 lines reused at the bottom of the window. Compute what we can
17596 if (first_unchanged_at_end_row
17597 /* No lines reused because we displayed everything up to the
17598 bottom of the window. */
17599 && it
.current_y
< it
.last_visible_y
)
17602 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
17604 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
17605 run
.current_y
= first_unchanged_at_end_row
->y
;
17606 run
.desired_y
= run
.current_y
+ dy
;
17607 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
17611 delta
= delta_bytes
= dvpos
= dy
17612 = run
.current_y
= run
.desired_y
= run
.height
= 0;
17613 first_unchanged_at_end_row
= NULL
;
17615 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
17618 /* Find the cursor if not already found. We have to decide whether
17619 PT will appear on this window (it sometimes doesn't, but this is
17620 not a very frequent case.) This decision has to be made before
17621 the current matrix is altered. A value of cursor.vpos < 0 means
17622 that PT is either in one of the lines beginning at
17623 first_unchanged_at_end_row or below the window. Don't care for
17624 lines that might be displayed later at the window end; as
17625 mentioned, this is not a frequent case. */
17626 if (w
->cursor
.vpos
< 0)
17628 /* Cursor in unchanged rows at the top? */
17629 if (PT
< CHARPOS (start_pos
)
17630 && last_unchanged_at_beg_row
)
17632 row
= row_containing_pos (w
, PT
,
17633 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
17634 last_unchanged_at_beg_row
+ 1, 0);
17636 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
17639 /* Start from first_unchanged_at_end_row looking for PT. */
17640 else if (first_unchanged_at_end_row
)
17642 row
= row_containing_pos (w
, PT
- delta
,
17643 first_unchanged_at_end_row
, NULL
, 0);
17645 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
17646 delta_bytes
, dy
, dvpos
);
17649 /* Give up if cursor was not found. */
17650 if (w
->cursor
.vpos
< 0)
17652 clear_glyph_matrix (w
->desired_matrix
);
17657 /* Don't let the cursor end in the scroll margins. */
17659 int this_scroll_margin
, cursor_height
;
17661 this_scroll_margin
=
17662 max (0, min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4));
17663 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
17664 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
17666 if ((w
->cursor
.y
< this_scroll_margin
17667 && CHARPOS (start
) > BEGV
)
17668 /* Old redisplay didn't take scroll margin into account at the bottom,
17669 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
17670 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
17671 ? cursor_height
+ this_scroll_margin
17672 : 1)) > it
.last_visible_y
)
17674 w
->cursor
.vpos
= -1;
17675 clear_glyph_matrix (w
->desired_matrix
);
17680 /* Scroll the display. Do it before changing the current matrix so
17681 that xterm.c doesn't get confused about where the cursor glyph is
17683 if (dy
&& run
.height
)
17687 if (FRAME_WINDOW_P (f
))
17689 FRAME_RIF (f
)->update_window_begin_hook (w
);
17690 FRAME_RIF (f
)->clear_window_mouse_face (w
);
17691 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
17692 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
17696 /* Terminal frame. In this case, dvpos gives the number of
17697 lines to scroll by; dvpos < 0 means scroll up. */
17699 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
17700 int from
= WINDOW_TOP_EDGE_LINE (w
) + from_vpos
;
17701 int end
= (WINDOW_TOP_EDGE_LINE (w
)
17702 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
17703 + window_internal_height (w
));
17705 #if defined (HAVE_GPM) || defined (MSDOS)
17706 x_clear_window_mouse_face (w
);
17708 /* Perform the operation on the screen. */
17711 /* Scroll last_unchanged_at_beg_row to the end of the
17712 window down dvpos lines. */
17713 set_terminal_window (f
, end
);
17715 /* On dumb terminals delete dvpos lines at the end
17716 before inserting dvpos empty lines. */
17717 if (!FRAME_SCROLL_REGION_OK (f
))
17718 ins_del_lines (f
, end
- dvpos
, -dvpos
);
17720 /* Insert dvpos empty lines in front of
17721 last_unchanged_at_beg_row. */
17722 ins_del_lines (f
, from
, dvpos
);
17724 else if (dvpos
< 0)
17726 /* Scroll up last_unchanged_at_beg_vpos to the end of
17727 the window to last_unchanged_at_beg_vpos - |dvpos|. */
17728 set_terminal_window (f
, end
);
17730 /* Delete dvpos lines in front of
17731 last_unchanged_at_beg_vpos. ins_del_lines will set
17732 the cursor to the given vpos and emit |dvpos| delete
17734 ins_del_lines (f
, from
+ dvpos
, dvpos
);
17736 /* On a dumb terminal insert dvpos empty lines at the
17738 if (!FRAME_SCROLL_REGION_OK (f
))
17739 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
17742 set_terminal_window (f
, 0);
17748 /* Shift reused rows of the current matrix to the right position.
17749 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
17751 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
17752 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
17755 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
17756 bottom_vpos
, dvpos
);
17757 clear_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
17760 else if (dvpos
> 0)
17762 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
17763 bottom_vpos
, dvpos
);
17764 clear_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
17765 first_unchanged_at_end_vpos
+ dvpos
);
17768 /* For frame-based redisplay, make sure that current frame and window
17769 matrix are in sync with respect to glyph memory. */
17770 if (!FRAME_WINDOW_P (f
))
17771 sync_frame_with_window_matrix_rows (w
);
17773 /* Adjust buffer positions in reused rows. */
17774 if (delta
|| delta_bytes
)
17775 increment_matrix_positions (current_matrix
,
17776 first_unchanged_at_end_vpos
+ dvpos
,
17777 bottom_vpos
, delta
, delta_bytes
);
17779 /* Adjust Y positions. */
17781 shift_glyph_matrix (w
, current_matrix
,
17782 first_unchanged_at_end_vpos
+ dvpos
,
17785 if (first_unchanged_at_end_row
)
17787 first_unchanged_at_end_row
+= dvpos
;
17788 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
17789 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
17790 first_unchanged_at_end_row
= NULL
;
17793 /* If scrolling up, there may be some lines to display at the end of
17795 last_text_row_at_end
= NULL
;
17798 /* Scrolling up can leave for example a partially visible line
17799 at the end of the window to be redisplayed. */
17800 /* Set last_row to the glyph row in the current matrix where the
17801 window end line is found. It has been moved up or down in
17802 the matrix by dvpos. */
17803 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
17804 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
17806 /* If last_row is the window end line, it should display text. */
17807 eassert (last_row
->displays_text_p
);
17809 /* If window end line was partially visible before, begin
17810 displaying at that line. Otherwise begin displaying with the
17811 line following it. */
17812 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
17814 init_to_row_start (&it
, w
, last_row
);
17815 it
.vpos
= last_vpos
;
17816 it
.current_y
= last_row
->y
;
17820 init_to_row_end (&it
, w
, last_row
);
17821 it
.vpos
= 1 + last_vpos
;
17822 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
17826 /* We may start in a continuation line. If so, we have to
17827 get the right continuation_lines_width and current_x. */
17828 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
17829 it
.hpos
= it
.current_x
= 0;
17831 /* Display the rest of the lines at the window end. */
17832 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
17833 while (it
.current_y
< it
.last_visible_y
17834 && !fonts_changed_p
)
17836 /* Is it always sure that the display agrees with lines in
17837 the current matrix? I don't think so, so we mark rows
17838 displayed invalid in the current matrix by setting their
17839 enabled_p flag to zero. */
17840 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
17841 if (display_line (&it
))
17842 last_text_row_at_end
= it
.glyph_row
- 1;
17846 /* Update window_end_pos and window_end_vpos. */
17847 if (first_unchanged_at_end_row
17848 && !last_text_row_at_end
)
17850 /* Window end line if one of the preserved rows from the current
17851 matrix. Set row to the last row displaying text in current
17852 matrix starting at first_unchanged_at_end_row, after
17854 eassert (first_unchanged_at_end_row
->displays_text_p
);
17855 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
17856 first_unchanged_at_end_row
);
17857 eassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
17859 wset_window_end_pos (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17860 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17861 wset_window_end_vpos
17862 (w
, make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
)));
17863 eassert (w
->window_end_bytepos
>= 0);
17864 IF_DEBUG (debug_method_add (w
, "A"));
17866 else if (last_text_row_at_end
)
17868 wset_window_end_pos
17869 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
)));
17870 w
->window_end_bytepos
17871 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
17872 wset_window_end_vpos
17873 (w
, make_number (MATRIX_ROW_VPOS (last_text_row_at_end
,
17875 eassert (w
->window_end_bytepos
>= 0);
17876 IF_DEBUG (debug_method_add (w
, "B"));
17878 else if (last_text_row
)
17880 /* We have displayed either to the end of the window or at the
17881 end of the window, i.e. the last row with text is to be found
17882 in the desired matrix. */
17883 wset_window_end_pos
17884 (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
)));
17885 w
->window_end_bytepos
17886 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
17887 wset_window_end_vpos
17888 (w
, make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
)));
17889 eassert (w
->window_end_bytepos
>= 0);
17891 else if (first_unchanged_at_end_row
== NULL
17892 && last_text_row
== NULL
17893 && last_text_row_at_end
== NULL
)
17895 /* Displayed to end of window, but no line containing text was
17896 displayed. Lines were deleted at the end of the window. */
17897 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
17898 int vpos
= XFASTINT (w
->window_end_vpos
);
17899 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
17900 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
17903 row
== NULL
&& vpos
>= first_vpos
;
17904 --vpos
, --current_row
, --desired_row
)
17906 if (desired_row
->enabled_p
)
17908 if (desired_row
->displays_text_p
)
17911 else if (current_row
->displays_text_p
)
17915 eassert (row
!= NULL
);
17916 wset_window_end_vpos (w
, make_number (vpos
+ 1));
17917 wset_window_end_pos (w
, make_number (Z
- MATRIX_ROW_END_CHARPOS (row
)));
17918 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17919 eassert (w
->window_end_bytepos
>= 0);
17920 IF_DEBUG (debug_method_add (w
, "C"));
17925 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
17926 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
17928 /* Record that display has not been completed. */
17929 wset_window_end_valid (w
, Qnil
);
17930 w
->desired_matrix
->no_scrolling_p
= 1;
17938 /***********************************************************************
17939 More debugging support
17940 ***********************************************************************/
17944 void dump_glyph_row (struct glyph_row
*, int, int) EXTERNALLY_VISIBLE
;
17945 void dump_glyph_matrix (struct glyph_matrix
*, int) EXTERNALLY_VISIBLE
;
17946 void dump_glyph (struct glyph_row
*, struct glyph
*, int) EXTERNALLY_VISIBLE
;
17949 /* Dump the contents of glyph matrix MATRIX on stderr.
17951 GLYPHS 0 means don't show glyph contents.
17952 GLYPHS 1 means show glyphs in short form
17953 GLYPHS > 1 means show glyphs in long form. */
17956 dump_glyph_matrix (struct glyph_matrix
*matrix
, int glyphs
)
17959 for (i
= 0; i
< matrix
->nrows
; ++i
)
17960 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
17964 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
17965 the glyph row and area where the glyph comes from. */
17968 dump_glyph (struct glyph_row
*row
, struct glyph
*glyph
, int area
)
17970 if (glyph
->type
== CHAR_GLYPH
)
17973 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17974 glyph
- row
->glyphs
[TEXT_AREA
],
17977 (BUFFERP (glyph
->object
)
17979 : (STRINGP (glyph
->object
)
17982 glyph
->pixel_width
,
17984 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
17988 glyph
->left_box_line_p
,
17989 glyph
->right_box_line_p
);
17991 else if (glyph
->type
== STRETCH_GLYPH
)
17994 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17995 glyph
- row
->glyphs
[TEXT_AREA
],
17998 (BUFFERP (glyph
->object
)
18000 : (STRINGP (glyph
->object
)
18003 glyph
->pixel_width
,
18007 glyph
->left_box_line_p
,
18008 glyph
->right_box_line_p
);
18010 else if (glyph
->type
== IMAGE_GLYPH
)
18013 " %5td %4c %6"pI
"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
18014 glyph
- row
->glyphs
[TEXT_AREA
],
18017 (BUFFERP (glyph
->object
)
18019 : (STRINGP (glyph
->object
)
18022 glyph
->pixel_width
,
18026 glyph
->left_box_line_p
,
18027 glyph
->right_box_line_p
);
18029 else if (glyph
->type
== COMPOSITE_GLYPH
)
18032 " %5td %4c %6"pI
"d %c %3d 0x%05x",
18033 glyph
- row
->glyphs
[TEXT_AREA
],
18036 (BUFFERP (glyph
->object
)
18038 : (STRINGP (glyph
->object
)
18041 glyph
->pixel_width
,
18043 if (glyph
->u
.cmp
.automatic
)
18046 glyph
->slice
.cmp
.from
, glyph
->slice
.cmp
.to
);
18047 fprintf (stderr
, " . %4d %1.1d%1.1d\n",
18049 glyph
->left_box_line_p
,
18050 glyph
->right_box_line_p
);
18055 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
18056 GLYPHS 0 means don't show glyph contents.
18057 GLYPHS 1 means show glyphs in short form
18058 GLYPHS > 1 means show glyphs in long form. */
18061 dump_glyph_row (struct glyph_row
*row
, int vpos
, int glyphs
)
18065 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
18066 fprintf (stderr
, "======================================================================\n");
18068 fprintf (stderr
, "%3d %5"pI
"d %5"pI
"d %4d %1.1d%1.1d%1.1d%1.1d\
18069 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
18071 MATRIX_ROW_START_CHARPOS (row
),
18072 MATRIX_ROW_END_CHARPOS (row
),
18073 row
->used
[TEXT_AREA
],
18074 row
->contains_overlapping_glyphs_p
,
18076 row
->truncated_on_left_p
,
18077 row
->truncated_on_right_p
,
18079 MATRIX_ROW_CONTINUATION_LINE_P (row
),
18080 row
->displays_text_p
,
18083 row
->ends_in_middle_of_char_p
,
18084 row
->starts_in_middle_of_char_p
,
18090 row
->visible_height
,
18093 fprintf (stderr
, "%9"pD
"d %5"pD
"d\t%5d\n", row
->start
.overlay_string_index
,
18094 row
->end
.overlay_string_index
,
18095 row
->continuation_lines_width
);
18096 fprintf (stderr
, "%9"pI
"d %5"pI
"d\n",
18097 CHARPOS (row
->start
.string_pos
),
18098 CHARPOS (row
->end
.string_pos
));
18099 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
18100 row
->end
.dpvec_index
);
18107 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18109 struct glyph
*glyph
= row
->glyphs
[area
];
18110 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
18112 /* Glyph for a line end in text. */
18113 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
18116 if (glyph
< glyph_end
)
18117 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
18119 for (; glyph
< glyph_end
; ++glyph
)
18120 dump_glyph (row
, glyph
, area
);
18123 else if (glyphs
== 1)
18127 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18129 char *s
= alloca (row
->used
[area
] + 1);
18132 for (i
= 0; i
< row
->used
[area
]; ++i
)
18134 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
18135 if (glyph
->type
== CHAR_GLYPH
18136 && glyph
->u
.ch
< 0x80
18137 && glyph
->u
.ch
>= ' ')
18138 s
[i
] = glyph
->u
.ch
;
18144 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
18150 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
18151 Sdump_glyph_matrix
, 0, 1, "p",
18152 doc
: /* Dump the current matrix of the selected window to stderr.
18153 Shows contents of glyph row structures. With non-nil
18154 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
18155 glyphs in short form, otherwise show glyphs in long form. */)
18156 (Lisp_Object glyphs
)
18158 struct window
*w
= XWINDOW (selected_window
);
18159 struct buffer
*buffer
= XBUFFER (w
->buffer
);
18161 fprintf (stderr
, "PT = %"pI
"d, BEGV = %"pI
"d. ZV = %"pI
"d\n",
18162 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
18163 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
18164 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
18165 fprintf (stderr
, "=============================================\n");
18166 dump_glyph_matrix (w
->current_matrix
,
18167 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 0);
18172 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
18173 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
18176 struct frame
*f
= XFRAME (selected_frame
);
18177 dump_glyph_matrix (f
->current_matrix
, 1);
18182 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
18183 doc
: /* Dump glyph row ROW to stderr.
18184 GLYPH 0 means don't dump glyphs.
18185 GLYPH 1 means dump glyphs in short form.
18186 GLYPH > 1 or omitted means dump glyphs in long form. */)
18187 (Lisp_Object row
, Lisp_Object glyphs
)
18189 struct glyph_matrix
*matrix
;
18192 CHECK_NUMBER (row
);
18193 matrix
= XWINDOW (selected_window
)->current_matrix
;
18195 if (vpos
>= 0 && vpos
< matrix
->nrows
)
18196 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
18198 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18203 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
18204 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
18205 GLYPH 0 means don't dump glyphs.
18206 GLYPH 1 means dump glyphs in short form.
18207 GLYPH > 1 or omitted means dump glyphs in long form. */)
18208 (Lisp_Object row
, Lisp_Object glyphs
)
18210 struct frame
*sf
= SELECTED_FRAME ();
18211 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
18214 CHECK_NUMBER (row
);
18216 if (vpos
>= 0 && vpos
< m
->nrows
)
18217 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
18218 TYPE_RANGED_INTEGERP (int, glyphs
) ? XINT (glyphs
) : 2);
18223 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
18224 doc
: /* Toggle tracing of redisplay.
18225 With ARG, turn tracing on if and only if ARG is positive. */)
18229 trace_redisplay_p
= !trace_redisplay_p
;
18232 arg
= Fprefix_numeric_value (arg
);
18233 trace_redisplay_p
= XINT (arg
) > 0;
18240 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
18241 doc
: /* Like `format', but print result to stderr.
18242 usage: (trace-to-stderr STRING &rest OBJECTS) */)
18243 (ptrdiff_t nargs
, Lisp_Object
*args
)
18245 Lisp_Object s
= Fformat (nargs
, args
);
18246 fprintf (stderr
, "%s", SDATA (s
));
18250 #endif /* GLYPH_DEBUG */
18254 /***********************************************************************
18255 Building Desired Matrix Rows
18256 ***********************************************************************/
18258 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
18259 Used for non-window-redisplay windows, and for windows w/o left fringe. */
18261 static struct glyph_row
*
18262 get_overlay_arrow_glyph_row (struct window
*w
, Lisp_Object overlay_arrow_string
)
18264 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
18265 struct buffer
*buffer
= XBUFFER (w
->buffer
);
18266 struct buffer
*old
= current_buffer
;
18267 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
18268 int arrow_len
= SCHARS (overlay_arrow_string
);
18269 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
18270 const unsigned char *p
;
18273 int n_glyphs_before
;
18275 set_buffer_temp (buffer
);
18276 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
18277 it
.glyph_row
->used
[TEXT_AREA
] = 0;
18278 SET_TEXT_POS (it
.position
, 0, 0);
18280 multibyte_p
= !NILP (BVAR (buffer
, enable_multibyte_characters
));
18282 while (p
< arrow_end
)
18284 Lisp_Object face
, ilisp
;
18286 /* Get the next character. */
18288 it
.c
= it
.char_to_display
= string_char_and_length (p
, &it
.len
);
18291 it
.c
= it
.char_to_display
= *p
, it
.len
= 1;
18292 if (! ASCII_CHAR_P (it
.c
))
18293 it
.char_to_display
= BYTE8_TO_CHAR (it
.c
);
18297 /* Get its face. */
18298 ilisp
= make_number (p
- arrow_string
);
18299 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
18300 it
.face_id
= compute_char_face (f
, it
.char_to_display
, face
);
18302 /* Compute its width, get its glyphs. */
18303 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
18304 SET_TEXT_POS (it
.position
, -1, -1);
18305 PRODUCE_GLYPHS (&it
);
18307 /* If this character doesn't fit any more in the line, we have
18308 to remove some glyphs. */
18309 if (it
.current_x
> it
.last_visible_x
)
18311 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
18316 set_buffer_temp (old
);
18317 return it
.glyph_row
;
18321 /* Insert truncation glyphs at the start of IT->glyph_row. Which
18322 glyphs to insert is determined by produce_special_glyphs. */
18325 insert_left_trunc_glyphs (struct it
*it
)
18327 struct it truncate_it
;
18328 struct glyph
*from
, *end
, *to
, *toend
;
18330 eassert (!FRAME_WINDOW_P (it
->f
)
18331 || (!it
->glyph_row
->reversed_p
18332 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0)
18333 || (it
->glyph_row
->reversed_p
18334 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0));
18336 /* Get the truncation glyphs. */
18338 truncate_it
.current_x
= 0;
18339 truncate_it
.face_id
= DEFAULT_FACE_ID
;
18340 truncate_it
.glyph_row
= &scratch_glyph_row
;
18341 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
18342 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
18343 truncate_it
.object
= make_number (0);
18344 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
18346 /* Overwrite glyphs from IT with truncation glyphs. */
18347 if (!it
->glyph_row
->reversed_p
)
18349 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18351 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18352 end
= from
+ tused
;
18353 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18354 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
18355 if (FRAME_WINDOW_P (it
->f
))
18357 /* On GUI frames, when variable-size fonts are displayed,
18358 the truncation glyphs may need more pixels than the row's
18359 glyphs they overwrite. We overwrite more glyphs to free
18360 enough screen real estate, and enlarge the stretch glyph
18361 on the right (see display_line), if there is one, to
18362 preserve the screen position of the truncation glyphs on
18365 struct glyph
*g
= to
;
18368 /* The first glyph could be partially visible, in which case
18369 it->glyph_row->x will be negative. But we want the left
18370 truncation glyphs to be aligned at the left margin of the
18371 window, so we override the x coordinate at which the row
18373 it
->glyph_row
->x
= 0;
18374 while (g
< toend
&& w
< it
->truncation_pixel_width
)
18376 w
+= g
->pixel_width
;
18379 if (g
- to
- tused
> 0)
18381 memmove (to
+ tused
, g
, (toend
- g
) * sizeof(*g
));
18382 it
->glyph_row
->used
[TEXT_AREA
] -= g
- to
- tused
;
18384 used
= it
->glyph_row
->used
[TEXT_AREA
];
18385 if (it
->glyph_row
->truncated_on_right_p
18386 && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
) == 0
18387 && it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].type
18390 int extra
= w
- it
->truncation_pixel_width
;
18392 it
->glyph_row
->glyphs
[TEXT_AREA
][used
- 2].pixel_width
+= extra
;
18399 /* There may be padding glyphs left over. Overwrite them too. */
18400 if (!FRAME_WINDOW_P (it
->f
))
18402 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
18404 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18411 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
18415 short tused
= truncate_it
.glyph_row
->used
[TEXT_AREA
];
18417 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
18418 that back to front. */
18419 end
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
18420 from
= end
+ truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18421 toend
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18422 to
= toend
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18423 if (FRAME_WINDOW_P (it
->f
))
18426 struct glyph
*g
= to
;
18428 while (g
>= toend
&& w
< it
->truncation_pixel_width
)
18430 w
+= g
->pixel_width
;
18433 if (to
- g
- tused
> 0)
18435 if (it
->glyph_row
->truncated_on_right_p
18436 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) == 0
18437 && it
->glyph_row
->glyphs
[TEXT_AREA
][1].type
== STRETCH_GLYPH
)
18439 int extra
= w
- it
->truncation_pixel_width
;
18441 it
->glyph_row
->glyphs
[TEXT_AREA
][1].pixel_width
+= extra
;
18445 while (from
>= end
&& to
>= toend
)
18447 if (!FRAME_WINDOW_P (it
->f
))
18449 while (to
>= toend
&& CHAR_GLYPH_PADDING_P (*to
))
18452 truncate_it
.glyph_row
->glyphs
[TEXT_AREA
]
18453 + truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
18454 while (from
>= end
&& to
>= toend
)
18460 /* Need to free some room before prepending additional
18462 int move_by
= from
- end
+ 1;
18463 struct glyph
*g0
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18464 struct glyph
*g
= g0
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
18466 for ( ; g
>= g0
; g
--)
18468 while (from
>= end
)
18470 it
->glyph_row
->used
[TEXT_AREA
] += move_by
;
18475 /* Compute the hash code for ROW. */
18477 row_hash (struct glyph_row
*row
)
18480 unsigned hashval
= 0;
18482 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
18483 for (k
= 0; k
< row
->used
[area
]; ++k
)
18484 hashval
= ((((hashval
<< 4) + (hashval
>> 24)) & 0x0fffffff)
18485 + row
->glyphs
[area
][k
].u
.val
18486 + row
->glyphs
[area
][k
].face_id
18487 + row
->glyphs
[area
][k
].padding_p
18488 + (row
->glyphs
[area
][k
].type
<< 2));
18493 /* Compute the pixel height and width of IT->glyph_row.
18495 Most of the time, ascent and height of a display line will be equal
18496 to the max_ascent and max_height values of the display iterator
18497 structure. This is not the case if
18499 1. We hit ZV without displaying anything. In this case, max_ascent
18500 and max_height will be zero.
18502 2. We have some glyphs that don't contribute to the line height.
18503 (The glyph row flag contributes_to_line_height_p is for future
18504 pixmap extensions).
18506 The first case is easily covered by using default values because in
18507 these cases, the line height does not really matter, except that it
18508 must not be zero. */
18511 compute_line_metrics (struct it
*it
)
18513 struct glyph_row
*row
= it
->glyph_row
;
18515 if (FRAME_WINDOW_P (it
->f
))
18517 int i
, min_y
, max_y
;
18519 /* The line may consist of one space only, that was added to
18520 place the cursor on it. If so, the row's height hasn't been
18522 if (row
->height
== 0)
18524 if (it
->max_ascent
+ it
->max_descent
== 0)
18525 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
18526 row
->ascent
= it
->max_ascent
;
18527 row
->height
= it
->max_ascent
+ it
->max_descent
;
18528 row
->phys_ascent
= it
->max_phys_ascent
;
18529 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
18530 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
18533 /* Compute the width of this line. */
18534 row
->pixel_width
= row
->x
;
18535 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
18536 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
18538 eassert (row
->pixel_width
>= 0);
18539 eassert (row
->ascent
>= 0 && row
->height
> 0);
18541 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
18542 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
18544 /* If first line's physical ascent is larger than its logical
18545 ascent, use the physical ascent, and make the row taller.
18546 This makes accented characters fully visible. */
18547 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
18548 && row
->phys_ascent
> row
->ascent
)
18550 row
->height
+= row
->phys_ascent
- row
->ascent
;
18551 row
->ascent
= row
->phys_ascent
;
18554 /* Compute how much of the line is visible. */
18555 row
->visible_height
= row
->height
;
18557 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
18558 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
18560 if (row
->y
< min_y
)
18561 row
->visible_height
-= min_y
- row
->y
;
18562 if (row
->y
+ row
->height
> max_y
)
18563 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
18567 row
->pixel_width
= row
->used
[TEXT_AREA
];
18568 if (row
->continued_p
)
18569 row
->pixel_width
-= it
->continuation_pixel_width
;
18570 else if (row
->truncated_on_right_p
)
18571 row
->pixel_width
-= it
->truncation_pixel_width
;
18572 row
->ascent
= row
->phys_ascent
= 0;
18573 row
->height
= row
->phys_height
= row
->visible_height
= 1;
18574 row
->extra_line_spacing
= 0;
18577 /* Compute a hash code for this row. */
18578 row
->hash
= row_hash (row
);
18580 it
->max_ascent
= it
->max_descent
= 0;
18581 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
18585 /* Append one space to the glyph row of iterator IT if doing a
18586 window-based redisplay. The space has the same face as
18587 IT->face_id. Value is non-zero if a space was added.
18589 This function is called to make sure that there is always one glyph
18590 at the end of a glyph row that the cursor can be set on under
18591 window-systems. (If there weren't such a glyph we would not know
18592 how wide and tall a box cursor should be displayed).
18594 At the same time this space let's a nicely handle clearing to the
18595 end of the line if the row ends in italic text. */
18598 append_space_for_newline (struct it
*it
, int default_face_p
)
18600 if (FRAME_WINDOW_P (it
->f
))
18602 int n
= it
->glyph_row
->used
[TEXT_AREA
];
18604 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
18605 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
18607 /* Save some values that must not be changed.
18608 Must save IT->c and IT->len because otherwise
18609 ITERATOR_AT_END_P wouldn't work anymore after
18610 append_space_for_newline has been called. */
18611 enum display_element_type saved_what
= it
->what
;
18612 int saved_c
= it
->c
, saved_len
= it
->len
;
18613 int saved_char_to_display
= it
->char_to_display
;
18614 int saved_x
= it
->current_x
;
18615 int saved_face_id
= it
->face_id
;
18616 struct text_pos saved_pos
;
18617 Lisp_Object saved_object
;
18620 saved_object
= it
->object
;
18621 saved_pos
= it
->position
;
18623 it
->what
= IT_CHARACTER
;
18624 memset (&it
->position
, 0, sizeof it
->position
);
18625 it
->object
= make_number (0);
18626 it
->c
= it
->char_to_display
= ' ';
18629 /* If the default face was remapped, be sure to use the
18630 remapped face for the appended newline. */
18631 if (default_face_p
)
18632 it
->face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);
18633 else if (it
->face_before_selective_p
)
18634 it
->face_id
= it
->saved_face_id
;
18635 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
18636 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
18638 PRODUCE_GLYPHS (it
);
18640 it
->override_ascent
= -1;
18641 it
->constrain_row_ascent_descent_p
= 0;
18642 it
->current_x
= saved_x
;
18643 it
->object
= saved_object
;
18644 it
->position
= saved_pos
;
18645 it
->what
= saved_what
;
18646 it
->face_id
= saved_face_id
;
18647 it
->len
= saved_len
;
18649 it
->char_to_display
= saved_char_to_display
;
18658 /* Extend the face of the last glyph in the text area of IT->glyph_row
18659 to the end of the display line. Called from display_line. If the
18660 glyph row is empty, add a space glyph to it so that we know the
18661 face to draw. Set the glyph row flag fill_line_p. If the glyph
18662 row is R2L, prepend a stretch glyph to cover the empty space to the
18663 left of the leftmost glyph. */
18666 extend_face_to_end_of_line (struct it
*it
)
18668 struct face
*face
, *default_face
;
18669 struct frame
*f
= it
->f
;
18671 /* If line is already filled, do nothing. Non window-system frames
18672 get a grace of one more ``pixel'' because their characters are
18673 1-``pixel'' wide, so they hit the equality too early. This grace
18674 is needed only for R2L rows that are not continued, to produce
18675 one extra blank where we could display the cursor. */
18676 if (it
->current_x
>= it
->last_visible_x
18677 + (!FRAME_WINDOW_P (f
)
18678 && it
->glyph_row
->reversed_p
18679 && !it
->glyph_row
->continued_p
))
18682 /* The default face, possibly remapped. */
18683 default_face
= FACE_FROM_ID (f
, lookup_basic_face (f
, DEFAULT_FACE_ID
));
18685 /* Face extension extends the background and box of IT->face_id
18686 to the end of the line. If the background equals the background
18687 of the frame, we don't have to do anything. */
18688 if (it
->face_before_selective_p
)
18689 face
= FACE_FROM_ID (f
, it
->saved_face_id
);
18691 face
= FACE_FROM_ID (f
, it
->face_id
);
18693 if (FRAME_WINDOW_P (f
)
18694 && it
->glyph_row
->displays_text_p
18695 && face
->box
== FACE_NO_BOX
18696 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
18698 && !it
->glyph_row
->reversed_p
)
18701 /* Set the glyph row flag indicating that the face of the last glyph
18702 in the text area has to be drawn to the end of the text area. */
18703 it
->glyph_row
->fill_line_p
= 1;
18705 /* If current character of IT is not ASCII, make sure we have the
18706 ASCII face. This will be automatically undone the next time
18707 get_next_display_element returns a multibyte character. Note
18708 that the character will always be single byte in unibyte
18710 if (!ASCII_CHAR_P (it
->c
))
18712 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
18715 if (FRAME_WINDOW_P (f
))
18717 /* If the row is empty, add a space with the current face of IT,
18718 so that we know which face to draw. */
18719 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
18721 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
18722 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= face
->id
;
18723 it
->glyph_row
->used
[TEXT_AREA
] = 1;
18725 #ifdef HAVE_WINDOW_SYSTEM
18726 if (it
->glyph_row
->reversed_p
)
18728 /* Prepend a stretch glyph to the row, such that the
18729 rightmost glyph will be drawn flushed all the way to the
18730 right margin of the window. The stretch glyph that will
18731 occupy the empty space, if any, to the left of the
18733 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (f
);
18734 struct glyph
*row_start
= it
->glyph_row
->glyphs
[TEXT_AREA
];
18735 struct glyph
*row_end
= row_start
+ it
->glyph_row
->used
[TEXT_AREA
];
18737 int row_width
, stretch_ascent
, stretch_width
;
18738 struct text_pos saved_pos
;
18739 int saved_face_id
, saved_avoid_cursor
;
18741 for (row_width
= 0, g
= row_start
; g
< row_end
; g
++)
18742 row_width
+= g
->pixel_width
;
18743 stretch_width
= window_box_width (it
->w
, TEXT_AREA
) - row_width
;
18744 if (stretch_width
> 0)
18747 (((it
->ascent
+ it
->descent
)
18748 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
18749 saved_pos
= it
->position
;
18750 memset (&it
->position
, 0, sizeof it
->position
);
18751 saved_avoid_cursor
= it
->avoid_cursor_p
;
18752 it
->avoid_cursor_p
= 1;
18753 saved_face_id
= it
->face_id
;
18754 /* The last row's stretch glyph should get the default
18755 face, to avoid painting the rest of the window with
18756 the region face, if the region ends at ZV. */
18757 if (it
->glyph_row
->ends_at_zv_p
)
18758 it
->face_id
= default_face
->id
;
18760 it
->face_id
= face
->id
;
18761 append_stretch_glyph (it
, make_number (0), stretch_width
,
18762 it
->ascent
+ it
->descent
, stretch_ascent
);
18763 it
->position
= saved_pos
;
18764 it
->avoid_cursor_p
= saved_avoid_cursor
;
18765 it
->face_id
= saved_face_id
;
18768 #endif /* HAVE_WINDOW_SYSTEM */
18772 /* Save some values that must not be changed. */
18773 int saved_x
= it
->current_x
;
18774 struct text_pos saved_pos
;
18775 Lisp_Object saved_object
;
18776 enum display_element_type saved_what
= it
->what
;
18777 int saved_face_id
= it
->face_id
;
18779 saved_object
= it
->object
;
18780 saved_pos
= it
->position
;
18782 it
->what
= IT_CHARACTER
;
18783 memset (&it
->position
, 0, sizeof it
->position
);
18784 it
->object
= make_number (0);
18785 it
->c
= it
->char_to_display
= ' ';
18787 /* The last row's blank glyphs should get the default face, to
18788 avoid painting the rest of the window with the region face,
18789 if the region ends at ZV. */
18790 if (it
->glyph_row
->ends_at_zv_p
)
18791 it
->face_id
= default_face
->id
;
18793 it
->face_id
= face
->id
;
18795 PRODUCE_GLYPHS (it
);
18797 while (it
->current_x
<= it
->last_visible_x
)
18798 PRODUCE_GLYPHS (it
);
18800 /* Don't count these blanks really. It would let us insert a left
18801 truncation glyph below and make us set the cursor on them, maybe. */
18802 it
->current_x
= saved_x
;
18803 it
->object
= saved_object
;
18804 it
->position
= saved_pos
;
18805 it
->what
= saved_what
;
18806 it
->face_id
= saved_face_id
;
18811 /* Value is non-zero if text starting at CHARPOS in current_buffer is
18812 trailing whitespace. */
18815 trailing_whitespace_p (ptrdiff_t charpos
)
18817 ptrdiff_t bytepos
= CHAR_TO_BYTE (charpos
);
18820 while (bytepos
< ZV_BYTE
18821 && (c
= FETCH_CHAR (bytepos
),
18822 c
== ' ' || c
== '\t'))
18825 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
18827 if (bytepos
!= PT_BYTE
)
18834 /* Highlight trailing whitespace, if any, in ROW. */
18837 highlight_trailing_whitespace (struct frame
*f
, struct glyph_row
*row
)
18839 int used
= row
->used
[TEXT_AREA
];
18843 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
18844 struct glyph
*glyph
= start
+ used
- 1;
18846 if (row
->reversed_p
)
18848 /* Right-to-left rows need to be processed in the opposite
18849 direction, so swap the edge pointers. */
18851 start
= row
->glyphs
[TEXT_AREA
] + used
- 1;
18854 /* Skip over glyphs inserted to display the cursor at the
18855 end of a line, for extending the face of the last glyph
18856 to the end of the line on terminals, and for truncation
18857 and continuation glyphs. */
18858 if (!row
->reversed_p
)
18860 while (glyph
>= start
18861 && glyph
->type
== CHAR_GLYPH
18862 && INTEGERP (glyph
->object
))
18867 while (glyph
<= start
18868 && glyph
->type
== CHAR_GLYPH
18869 && INTEGERP (glyph
->object
))
18873 /* If last glyph is a space or stretch, and it's trailing
18874 whitespace, set the face of all trailing whitespace glyphs in
18875 IT->glyph_row to `trailing-whitespace'. */
18876 if ((row
->reversed_p
? glyph
<= start
: glyph
>= start
)
18877 && BUFFERP (glyph
->object
)
18878 && (glyph
->type
== STRETCH_GLYPH
18879 || (glyph
->type
== CHAR_GLYPH
18880 && glyph
->u
.ch
== ' '))
18881 && trailing_whitespace_p (glyph
->charpos
))
18883 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
18887 if (!row
->reversed_p
)
18889 while (glyph
>= start
18890 && BUFFERP (glyph
->object
)
18891 && (glyph
->type
== STRETCH_GLYPH
18892 || (glyph
->type
== CHAR_GLYPH
18893 && glyph
->u
.ch
== ' ')))
18894 (glyph
--)->face_id
= face_id
;
18898 while (glyph
<= start
18899 && BUFFERP (glyph
->object
)
18900 && (glyph
->type
== STRETCH_GLYPH
18901 || (glyph
->type
== CHAR_GLYPH
18902 && glyph
->u
.ch
== ' ')))
18903 (glyph
++)->face_id
= face_id
;
18910 /* Value is non-zero if glyph row ROW should be
18911 used to hold the cursor. */
18914 cursor_row_p (struct glyph_row
*row
)
18918 if (PT
== CHARPOS (row
->end
.pos
)
18919 || PT
== MATRIX_ROW_END_CHARPOS (row
))
18921 /* Suppose the row ends on a string.
18922 Unless the row is continued, that means it ends on a newline
18923 in the string. If it's anything other than a display string
18924 (e.g., a before-string from an overlay), we don't want the
18925 cursor there. (This heuristic seems to give the optimal
18926 behavior for the various types of multi-line strings.)
18927 One exception: if the string has `cursor' property on one of
18928 its characters, we _do_ want the cursor there. */
18929 if (CHARPOS (row
->end
.string_pos
) >= 0)
18931 if (row
->continued_p
)
18935 /* Check for `display' property. */
18936 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
18937 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
18938 struct glyph
*glyph
;
18941 for (glyph
= end
; glyph
>= beg
; --glyph
)
18942 if (STRINGP (glyph
->object
))
18945 = Fget_char_property (make_number (PT
),
18949 && display_prop_string_p (prop
, glyph
->object
));
18950 /* If there's a `cursor' property on one of the
18951 string's characters, this row is a cursor row,
18952 even though this is not a display string. */
18955 Lisp_Object s
= glyph
->object
;
18957 for ( ; glyph
>= beg
&& EQ (glyph
->object
, s
); --glyph
)
18959 ptrdiff_t gpos
= glyph
->charpos
;
18961 if (!NILP (Fget_char_property (make_number (gpos
),
18973 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
18975 /* If the row ends in middle of a real character,
18976 and the line is continued, we want the cursor here.
18977 That's because CHARPOS (ROW->end.pos) would equal
18978 PT if PT is before the character. */
18979 if (!row
->ends_in_ellipsis_p
)
18980 result
= row
->continued_p
;
18982 /* If the row ends in an ellipsis, then
18983 CHARPOS (ROW->end.pos) will equal point after the
18984 invisible text. We want that position to be displayed
18985 after the ellipsis. */
18988 /* If the row ends at ZV, display the cursor at the end of that
18989 row instead of at the start of the row below. */
18990 else if (row
->ends_at_zv_p
)
19001 /* Push the property PROP so that it will be rendered at the current
19002 position in IT. Return 1 if PROP was successfully pushed, 0
19003 otherwise. Called from handle_line_prefix to handle the
19004 `line-prefix' and `wrap-prefix' properties. */
19007 push_prefix_prop (struct it
*it
, Lisp_Object prop
)
19009 struct text_pos pos
=
19010 STRINGP (it
->string
) ? it
->current
.string_pos
: it
->current
.pos
;
19012 eassert (it
->method
== GET_FROM_BUFFER
19013 || it
->method
== GET_FROM_DISPLAY_VECTOR
19014 || it
->method
== GET_FROM_STRING
);
19016 /* We need to save the current buffer/string position, so it will be
19017 restored by pop_it, because iterate_out_of_display_property
19018 depends on that being set correctly, but some situations leave
19019 it->position not yet set when this function is called. */
19020 push_it (it
, &pos
);
19022 if (STRINGP (prop
))
19024 if (SCHARS (prop
) == 0)
19031 it
->string_from_prefix_prop_p
= 1;
19032 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
19033 it
->current
.overlay_string_index
= -1;
19034 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
19035 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
19036 it
->method
= GET_FROM_STRING
;
19037 it
->stop_charpos
= 0;
19039 it
->base_level_stop
= 0;
19041 /* Force paragraph direction to be that of the parent
19043 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
19044 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
19046 it
->paragraph_embedding
= L2R
;
19048 /* Set up the bidi iterator for this display string. */
19051 it
->bidi_it
.string
.lstring
= it
->string
;
19052 it
->bidi_it
.string
.s
= NULL
;
19053 it
->bidi_it
.string
.schars
= it
->end_charpos
;
19054 it
->bidi_it
.string
.bufpos
= IT_CHARPOS (*it
);
19055 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
19056 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
19057 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
19060 else if (CONSP (prop
) && EQ (XCAR (prop
), Qspace
))
19062 it
->method
= GET_FROM_STRETCH
;
19065 #ifdef HAVE_WINDOW_SYSTEM
19066 else if (IMAGEP (prop
))
19068 it
->what
= IT_IMAGE
;
19069 it
->image_id
= lookup_image (it
->f
, prop
);
19070 it
->method
= GET_FROM_IMAGE
;
19072 #endif /* HAVE_WINDOW_SYSTEM */
19075 pop_it (it
); /* bogus display property, give up */
19082 /* Return the character-property PROP at the current position in IT. */
19085 get_it_property (struct it
*it
, Lisp_Object prop
)
19087 Lisp_Object position
;
19089 if (STRINGP (it
->object
))
19090 position
= make_number (IT_STRING_CHARPOS (*it
));
19091 else if (BUFFERP (it
->object
))
19092 position
= make_number (IT_CHARPOS (*it
));
19096 return Fget_char_property (position
, prop
, it
->object
);
19099 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
19102 handle_line_prefix (struct it
*it
)
19104 Lisp_Object prefix
;
19106 if (it
->continuation_lines_width
> 0)
19108 prefix
= get_it_property (it
, Qwrap_prefix
);
19110 prefix
= Vwrap_prefix
;
19114 prefix
= get_it_property (it
, Qline_prefix
);
19116 prefix
= Vline_prefix
;
19118 if (! NILP (prefix
) && push_prefix_prop (it
, prefix
))
19120 /* If the prefix is wider than the window, and we try to wrap
19121 it, it would acquire its own wrap prefix, and so on till the
19122 iterator stack overflows. So, don't wrap the prefix. */
19123 it
->line_wrap
= TRUNCATE
;
19124 it
->avoid_cursor_p
= 1;
19130 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
19131 only for R2L lines from display_line and display_string, when they
19132 decide that too many glyphs were produced by PRODUCE_GLYPHS, and
19133 the line/string needs to be continued on the next glyph row. */
19135 unproduce_glyphs (struct it
*it
, int n
)
19137 struct glyph
*glyph
, *end
;
19139 eassert (it
->glyph_row
);
19140 eassert (it
->glyph_row
->reversed_p
);
19141 eassert (it
->area
== TEXT_AREA
);
19142 eassert (n
<= it
->glyph_row
->used
[TEXT_AREA
]);
19144 if (n
> it
->glyph_row
->used
[TEXT_AREA
])
19145 n
= it
->glyph_row
->used
[TEXT_AREA
];
19146 glyph
= it
->glyph_row
->glyphs
[TEXT_AREA
] + n
;
19147 end
= it
->glyph_row
->glyphs
[TEXT_AREA
] + it
->glyph_row
->used
[TEXT_AREA
];
19148 for ( ; glyph
< end
; glyph
++)
19149 glyph
[-n
] = *glyph
;
19152 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
19153 and ROW->maxpos. */
19155 find_row_edges (struct it
*it
, struct glyph_row
*row
,
19156 ptrdiff_t min_pos
, ptrdiff_t min_bpos
,
19157 ptrdiff_t max_pos
, ptrdiff_t max_bpos
)
19159 /* FIXME: Revisit this when glyph ``spilling'' in continuation
19160 lines' rows is implemented for bidi-reordered rows. */
19162 /* ROW->minpos is the value of min_pos, the minimal buffer position
19163 we have in ROW, or ROW->start.pos if that is smaller. */
19164 if (min_pos
<= ZV
&& min_pos
< row
->start
.pos
.charpos
)
19165 SET_TEXT_POS (row
->minpos
, min_pos
, min_bpos
);
19167 /* We didn't find buffer positions smaller than ROW->start, or
19168 didn't find _any_ valid buffer positions in any of the glyphs,
19169 so we must trust the iterator's computed positions. */
19170 row
->minpos
= row
->start
.pos
;
19173 max_pos
= CHARPOS (it
->current
.pos
);
19174 max_bpos
= BYTEPOS (it
->current
.pos
);
19177 /* Here are the various use-cases for ending the row, and the
19178 corresponding values for ROW->maxpos:
19180 Line ends in a newline from buffer eol_pos + 1
19181 Line is continued from buffer max_pos + 1
19182 Line is truncated on right it->current.pos
19183 Line ends in a newline from string max_pos + 1(*)
19184 (*) + 1 only when line ends in a forward scan
19185 Line is continued from string max_pos
19186 Line is continued from display vector max_pos
19187 Line is entirely from a string min_pos == max_pos
19188 Line is entirely from a display vector min_pos == max_pos
19189 Line that ends at ZV ZV
19191 If you discover other use-cases, please add them here as
19193 if (row
->ends_at_zv_p
)
19194 row
->maxpos
= it
->current
.pos
;
19195 else if (row
->used
[TEXT_AREA
])
19197 int seen_this_string
= 0;
19198 struct glyph_row
*r1
= row
- 1;
19200 /* Did we see the same display string on the previous row? */
19201 if (STRINGP (it
->object
)
19202 /* this is not the first row */
19203 && row
> it
->w
->desired_matrix
->rows
19204 /* previous row is not the header line */
19205 && !r1
->mode_line_p
19206 /* previous row also ends in a newline from a string */
19207 && r1
->ends_in_newline_from_string_p
)
19209 struct glyph
*start
, *end
;
19211 /* Search for the last glyph of the previous row that came
19212 from buffer or string. Depending on whether the row is
19213 L2R or R2L, we need to process it front to back or the
19214 other way round. */
19215 if (!r1
->reversed_p
)
19217 start
= r1
->glyphs
[TEXT_AREA
];
19218 end
= start
+ r1
->used
[TEXT_AREA
];
19219 /* Glyphs inserted by redisplay have an integer (zero)
19220 as their object. */
19222 && INTEGERP ((end
- 1)->object
)
19223 && (end
- 1)->charpos
<= 0)
19227 if (EQ ((end
- 1)->object
, it
->object
))
19228 seen_this_string
= 1;
19231 /* If all the glyphs of the previous row were inserted
19232 by redisplay, it means the previous row was
19233 produced from a single newline, which is only
19234 possible if that newline came from the same string
19235 as the one which produced this ROW. */
19236 seen_this_string
= 1;
19240 end
= r1
->glyphs
[TEXT_AREA
] - 1;
19241 start
= end
+ r1
->used
[TEXT_AREA
];
19243 && INTEGERP ((end
+ 1)->object
)
19244 && (end
+ 1)->charpos
<= 0)
19248 if (EQ ((end
+ 1)->object
, it
->object
))
19249 seen_this_string
= 1;
19252 seen_this_string
= 1;
19255 /* Take note of each display string that covers a newline only
19256 once, the first time we see it. This is for when a display
19257 string includes more than one newline in it. */
19258 if (row
->ends_in_newline_from_string_p
&& !seen_this_string
)
19260 /* If we were scanning the buffer forward when we displayed
19261 the string, we want to account for at least one buffer
19262 position that belongs to this row (position covered by
19263 the display string), so that cursor positioning will
19264 consider this row as a candidate when point is at the end
19265 of the visual line represented by this row. This is not
19266 required when scanning back, because max_pos will already
19267 have a much larger value. */
19268 if (CHARPOS (row
->end
.pos
) > max_pos
)
19269 INC_BOTH (max_pos
, max_bpos
);
19270 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19272 else if (CHARPOS (it
->eol_pos
) > 0)
19273 SET_TEXT_POS (row
->maxpos
,
19274 CHARPOS (it
->eol_pos
) + 1, BYTEPOS (it
->eol_pos
) + 1);
19275 else if (row
->continued_p
)
19277 /* If max_pos is different from IT's current position, it
19278 means IT->method does not belong to the display element
19279 at max_pos. However, it also means that the display
19280 element at max_pos was displayed in its entirety on this
19281 line, which is equivalent to saying that the next line
19282 starts at the next buffer position. */
19283 if (IT_CHARPOS (*it
) == max_pos
&& it
->method
!= GET_FROM_BUFFER
)
19284 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19287 INC_BOTH (max_pos
, max_bpos
);
19288 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
19291 else if (row
->truncated_on_right_p
)
19292 /* display_line already called reseat_at_next_visible_line_start,
19293 which puts the iterator at the beginning of the next line, in
19294 the logical order. */
19295 row
->maxpos
= it
->current
.pos
;
19296 else if (max_pos
== min_pos
&& it
->method
!= GET_FROM_BUFFER
)
19297 /* A line that is entirely from a string/image/stretch... */
19298 row
->maxpos
= row
->minpos
;
19303 row
->maxpos
= it
->current
.pos
;
19306 /* Construct the glyph row IT->glyph_row in the desired matrix of
19307 IT->w from text at the current position of IT. See dispextern.h
19308 for an overview of struct it. Value is non-zero if
19309 IT->glyph_row displays text, as opposed to a line displaying ZV
19313 display_line (struct it
*it
)
19315 struct glyph_row
*row
= it
->glyph_row
;
19316 Lisp_Object overlay_arrow_string
;
19318 void *wrap_data
= NULL
;
19319 int may_wrap
= 0, wrap_x
IF_LINT (= 0);
19320 int wrap_row_used
= -1;
19321 int wrap_row_ascent
IF_LINT (= 0), wrap_row_height
IF_LINT (= 0);
19322 int wrap_row_phys_ascent
IF_LINT (= 0), wrap_row_phys_height
IF_LINT (= 0);
19323 int wrap_row_extra_line_spacing
IF_LINT (= 0);
19324 ptrdiff_t wrap_row_min_pos
IF_LINT (= 0), wrap_row_min_bpos
IF_LINT (= 0);
19325 ptrdiff_t wrap_row_max_pos
IF_LINT (= 0), wrap_row_max_bpos
IF_LINT (= 0);
19327 ptrdiff_t min_pos
= ZV
+ 1, max_pos
= 0;
19328 ptrdiff_t min_bpos
IF_LINT (= 0), max_bpos
IF_LINT (= 0);
19330 /* We always start displaying at hpos zero even if hscrolled. */
19331 eassert (it
->hpos
== 0 && it
->current_x
== 0);
19333 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
19334 >= it
->w
->desired_matrix
->nrows
)
19336 it
->w
->nrows_scale_factor
++;
19337 fonts_changed_p
= 1;
19341 /* Is IT->w showing the region? */
19342 wset_region_showing (it
->w
, it
->region_beg_charpos
> 0 ? Qt
: Qnil
);
19344 /* Clear the result glyph row and enable it. */
19345 prepare_desired_row (row
);
19347 row
->y
= it
->current_y
;
19348 row
->start
= it
->start
;
19349 row
->continuation_lines_width
= it
->continuation_lines_width
;
19350 row
->displays_text_p
= 1;
19351 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
19352 it
->starts_in_middle_of_char_p
= 0;
19354 /* Arrange the overlays nicely for our purposes. Usually, we call
19355 display_line on only one line at a time, in which case this
19356 can't really hurt too much, or we call it on lines which appear
19357 one after another in the buffer, in which case all calls to
19358 recenter_overlay_lists but the first will be pretty cheap. */
19359 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
19361 /* Move over display elements that are not visible because we are
19362 hscrolled. This may stop at an x-position < IT->first_visible_x
19363 if the first glyph is partially visible or if we hit a line end. */
19364 if (it
->current_x
< it
->first_visible_x
)
19366 enum move_it_result move_result
;
19368 this_line_min_pos
= row
->start
.pos
;
19369 move_result
= move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
19370 MOVE_TO_POS
| MOVE_TO_X
);
19371 /* If we are under a large hscroll, move_it_in_display_line_to
19372 could hit the end of the line without reaching
19373 it->first_visible_x. Pretend that we did reach it. This is
19374 especially important on a TTY, where we will call
19375 extend_face_to_end_of_line, which needs to know how many
19376 blank glyphs to produce. */
19377 if (it
->current_x
< it
->first_visible_x
19378 && (move_result
== MOVE_NEWLINE_OR_CR
19379 || move_result
== MOVE_POS_MATCH_OR_ZV
))
19380 it
->current_x
= it
->first_visible_x
;
19382 /* Record the smallest positions seen while we moved over
19383 display elements that are not visible. This is needed by
19384 redisplay_internal for optimizing the case where the cursor
19385 stays inside the same line. The rest of this function only
19386 considers positions that are actually displayed, so
19387 RECORD_MAX_MIN_POS will not otherwise record positions that
19388 are hscrolled to the left of the left edge of the window. */
19389 min_pos
= CHARPOS (this_line_min_pos
);
19390 min_bpos
= BYTEPOS (this_line_min_pos
);
19394 /* We only do this when not calling `move_it_in_display_line_to'
19395 above, because move_it_in_display_line_to calls
19396 handle_line_prefix itself. */
19397 handle_line_prefix (it
);
19400 /* Get the initial row height. This is either the height of the
19401 text hscrolled, if there is any, or zero. */
19402 row
->ascent
= it
->max_ascent
;
19403 row
->height
= it
->max_ascent
+ it
->max_descent
;
19404 row
->phys_ascent
= it
->max_phys_ascent
;
19405 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
19406 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
19408 /* Utility macro to record max and min buffer positions seen until now. */
19409 #define RECORD_MAX_MIN_POS(IT) \
19412 int composition_p = !STRINGP ((IT)->string) \
19413 && ((IT)->what == IT_COMPOSITION); \
19414 ptrdiff_t current_pos = \
19415 composition_p ? (IT)->cmp_it.charpos \
19416 : IT_CHARPOS (*(IT)); \
19417 ptrdiff_t current_bpos = \
19418 composition_p ? CHAR_TO_BYTE (current_pos) \
19419 : IT_BYTEPOS (*(IT)); \
19420 if (current_pos < min_pos) \
19422 min_pos = current_pos; \
19423 min_bpos = current_bpos; \
19425 if (IT_CHARPOS (*it) > max_pos) \
19427 max_pos = IT_CHARPOS (*it); \
19428 max_bpos = IT_BYTEPOS (*it); \
19433 /* Loop generating characters. The loop is left with IT on the next
19434 character to display. */
19437 int n_glyphs_before
, hpos_before
, x_before
;
19439 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
19441 /* Retrieve the next thing to display. Value is zero if end of
19443 if (!get_next_display_element (it
))
19445 /* Maybe add a space at the end of this line that is used to
19446 display the cursor there under X. Set the charpos of the
19447 first glyph of blank lines not corresponding to any text
19449 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19450 row
->exact_window_width_line_p
= 1;
19451 else if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
19452 || row
->used
[TEXT_AREA
] == 0)
19454 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
19455 row
->displays_text_p
= 0;
19457 if (!NILP (BVAR (XBUFFER (it
->w
->buffer
), indicate_empty_lines
))
19458 && (!MINI_WINDOW_P (it
->w
)
19459 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
19460 row
->indicate_empty_line_p
= 1;
19463 it
->continuation_lines_width
= 0;
19464 row
->ends_at_zv_p
= 1;
19465 /* A row that displays right-to-left text must always have
19466 its last face extended all the way to the end of line,
19467 even if this row ends in ZV, because we still write to
19468 the screen left to right. We also need to extend the
19469 last face if the default face is remapped to some
19470 different face, otherwise the functions that clear
19471 portions of the screen will clear with the default face's
19472 background color. */
19473 if (row
->reversed_p
19474 || lookup_basic_face (it
->f
, DEFAULT_FACE_ID
) != DEFAULT_FACE_ID
)
19475 extend_face_to_end_of_line (it
);
19479 /* Now, get the metrics of what we want to display. This also
19480 generates glyphs in `row' (which is IT->glyph_row). */
19481 n_glyphs_before
= row
->used
[TEXT_AREA
];
19484 /* Remember the line height so far in case the next element doesn't
19485 fit on the line. */
19486 if (it
->line_wrap
!= TRUNCATE
)
19488 ascent
= it
->max_ascent
;
19489 descent
= it
->max_descent
;
19490 phys_ascent
= it
->max_phys_ascent
;
19491 phys_descent
= it
->max_phys_descent
;
19493 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
19495 if (IT_DISPLAYING_WHITESPACE (it
))
19499 SAVE_IT (wrap_it
, *it
, wrap_data
);
19501 wrap_row_used
= row
->used
[TEXT_AREA
];
19502 wrap_row_ascent
= row
->ascent
;
19503 wrap_row_height
= row
->height
;
19504 wrap_row_phys_ascent
= row
->phys_ascent
;
19505 wrap_row_phys_height
= row
->phys_height
;
19506 wrap_row_extra_line_spacing
= row
->extra_line_spacing
;
19507 wrap_row_min_pos
= min_pos
;
19508 wrap_row_min_bpos
= min_bpos
;
19509 wrap_row_max_pos
= max_pos
;
19510 wrap_row_max_bpos
= max_bpos
;
19516 PRODUCE_GLYPHS (it
);
19518 /* If this display element was in marginal areas, continue with
19520 if (it
->area
!= TEXT_AREA
)
19522 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19523 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19524 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19525 row
->phys_height
= max (row
->phys_height
,
19526 it
->max_phys_ascent
+ it
->max_phys_descent
);
19527 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19528 it
->max_extra_line_spacing
);
19529 set_iterator_to_next (it
, 1);
19533 /* Does the display element fit on the line? If we truncate
19534 lines, we should draw past the right edge of the window. If
19535 we don't truncate, we want to stop so that we can display the
19536 continuation glyph before the right margin. If lines are
19537 continued, there are two possible strategies for characters
19538 resulting in more than 1 glyph (e.g. tabs): Display as many
19539 glyphs as possible in this line and leave the rest for the
19540 continuation line, or display the whole element in the next
19541 line. Original redisplay did the former, so we do it also. */
19542 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
19543 hpos_before
= it
->hpos
;
19546 if (/* Not a newline. */
19548 /* Glyphs produced fit entirely in the line. */
19549 && it
->current_x
< it
->last_visible_x
)
19551 it
->hpos
+= nglyphs
;
19552 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19553 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19554 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19555 row
->phys_height
= max (row
->phys_height
,
19556 it
->max_phys_ascent
+ it
->max_phys_descent
);
19557 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19558 it
->max_extra_line_spacing
);
19559 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
19560 row
->x
= x
- it
->first_visible_x
;
19561 /* Record the maximum and minimum buffer positions seen so
19562 far in glyphs that will be displayed by this row. */
19564 RECORD_MAX_MIN_POS (it
);
19569 struct glyph
*glyph
;
19571 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
19573 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
19574 new_x
= x
+ glyph
->pixel_width
;
19576 if (/* Lines are continued. */
19577 it
->line_wrap
!= TRUNCATE
19578 && (/* Glyph doesn't fit on the line. */
19579 new_x
> it
->last_visible_x
19580 /* Or it fits exactly on a window system frame. */
19581 || (new_x
== it
->last_visible_x
19582 && FRAME_WINDOW_P (it
->f
)
19583 && (row
->reversed_p
19584 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19585 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)))))
19587 /* End of a continued line. */
19590 || (new_x
== it
->last_visible_x
19591 && FRAME_WINDOW_P (it
->f
)
19592 && (row
->reversed_p
19593 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19594 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
))))
19596 /* Current glyph is the only one on the line or
19597 fits exactly on the line. We must continue
19598 the line because we can't draw the cursor
19599 after the glyph. */
19600 row
->continued_p
= 1;
19601 it
->current_x
= new_x
;
19602 it
->continuation_lines_width
+= new_x
;
19604 if (i
== nglyphs
- 1)
19606 /* If line-wrap is on, check if a previous
19607 wrap point was found. */
19608 if (wrap_row_used
> 0
19609 /* Even if there is a previous wrap
19610 point, continue the line here as
19611 usual, if (i) the previous character
19612 was a space or tab AND (ii) the
19613 current character is not. */
19615 || IT_DISPLAYING_WHITESPACE (it
)))
19618 /* Record the maximum and minimum buffer
19619 positions seen so far in glyphs that will be
19620 displayed by this row. */
19622 RECORD_MAX_MIN_POS (it
);
19623 set_iterator_to_next (it
, 1);
19624 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19626 if (!get_next_display_element (it
))
19628 row
->exact_window_width_line_p
= 1;
19629 it
->continuation_lines_width
= 0;
19630 row
->continued_p
= 0;
19631 row
->ends_at_zv_p
= 1;
19633 else if (ITERATOR_AT_END_OF_LINE_P (it
))
19635 row
->continued_p
= 0;
19636 row
->exact_window_width_line_p
= 1;
19640 else if (it
->bidi_p
)
19641 RECORD_MAX_MIN_POS (it
);
19643 else if (CHAR_GLYPH_PADDING_P (*glyph
)
19644 && !FRAME_WINDOW_P (it
->f
))
19646 /* A padding glyph that doesn't fit on this line.
19647 This means the whole character doesn't fit
19649 if (row
->reversed_p
)
19650 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
19651 - n_glyphs_before
);
19652 row
->used
[TEXT_AREA
] = n_glyphs_before
;
19654 /* Fill the rest of the row with continuation
19655 glyphs like in 20.x. */
19656 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
19657 < row
->glyphs
[1 + TEXT_AREA
])
19658 produce_special_glyphs (it
, IT_CONTINUATION
);
19660 row
->continued_p
= 1;
19661 it
->current_x
= x_before
;
19662 it
->continuation_lines_width
+= x_before
;
19664 /* Restore the height to what it was before the
19665 element not fitting on the line. */
19666 it
->max_ascent
= ascent
;
19667 it
->max_descent
= descent
;
19668 it
->max_phys_ascent
= phys_ascent
;
19669 it
->max_phys_descent
= phys_descent
;
19671 else if (wrap_row_used
> 0)
19674 if (row
->reversed_p
)
19675 unproduce_glyphs (it
,
19676 row
->used
[TEXT_AREA
] - wrap_row_used
);
19677 RESTORE_IT (it
, &wrap_it
, wrap_data
);
19678 it
->continuation_lines_width
+= wrap_x
;
19679 row
->used
[TEXT_AREA
] = wrap_row_used
;
19680 row
->ascent
= wrap_row_ascent
;
19681 row
->height
= wrap_row_height
;
19682 row
->phys_ascent
= wrap_row_phys_ascent
;
19683 row
->phys_height
= wrap_row_phys_height
;
19684 row
->extra_line_spacing
= wrap_row_extra_line_spacing
;
19685 min_pos
= wrap_row_min_pos
;
19686 min_bpos
= wrap_row_min_bpos
;
19687 max_pos
= wrap_row_max_pos
;
19688 max_bpos
= wrap_row_max_bpos
;
19689 row
->continued_p
= 1;
19690 row
->ends_at_zv_p
= 0;
19691 row
->exact_window_width_line_p
= 0;
19692 it
->continuation_lines_width
+= x
;
19694 /* Make sure that a non-default face is extended
19695 up to the right margin of the window. */
19696 extend_face_to_end_of_line (it
);
19698 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
19700 /* A TAB that extends past the right edge of the
19701 window. This produces a single glyph on
19702 window system frames. We leave the glyph in
19703 this row and let it fill the row, but don't
19704 consume the TAB. */
19705 if ((row
->reversed_p
19706 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19707 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19708 produce_special_glyphs (it
, IT_CONTINUATION
);
19709 it
->continuation_lines_width
+= it
->last_visible_x
;
19710 row
->ends_in_middle_of_char_p
= 1;
19711 row
->continued_p
= 1;
19712 glyph
->pixel_width
= it
->last_visible_x
- x
;
19713 it
->starts_in_middle_of_char_p
= 1;
19717 /* Something other than a TAB that draws past
19718 the right edge of the window. Restore
19719 positions to values before the element. */
19720 if (row
->reversed_p
)
19721 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
19722 - (n_glyphs_before
+ i
));
19723 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
19725 /* Display continuation glyphs. */
19726 it
->current_x
= x_before
;
19727 it
->continuation_lines_width
+= x
;
19728 if (!FRAME_WINDOW_P (it
->f
)
19729 || (row
->reversed_p
19730 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19731 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19732 produce_special_glyphs (it
, IT_CONTINUATION
);
19733 row
->continued_p
= 1;
19735 extend_face_to_end_of_line (it
);
19737 if (nglyphs
> 1 && i
> 0)
19739 row
->ends_in_middle_of_char_p
= 1;
19740 it
->starts_in_middle_of_char_p
= 1;
19743 /* Restore the height to what it was before the
19744 element not fitting on the line. */
19745 it
->max_ascent
= ascent
;
19746 it
->max_descent
= descent
;
19747 it
->max_phys_ascent
= phys_ascent
;
19748 it
->max_phys_descent
= phys_descent
;
19753 else if (new_x
> it
->first_visible_x
)
19755 /* Increment number of glyphs actually displayed. */
19758 /* Record the maximum and minimum buffer positions
19759 seen so far in glyphs that will be displayed by
19762 RECORD_MAX_MIN_POS (it
);
19764 if (x
< it
->first_visible_x
)
19765 /* Glyph is partially visible, i.e. row starts at
19766 negative X position. */
19767 row
->x
= x
- it
->first_visible_x
;
19771 /* Glyph is completely off the left margin of the
19772 window. This should not happen because of the
19773 move_it_in_display_line at the start of this
19774 function, unless the text display area of the
19775 window is empty. */
19776 eassert (it
->first_visible_x
<= it
->last_visible_x
);
19779 /* Even if this display element produced no glyphs at all,
19780 we want to record its position. */
19781 if (it
->bidi_p
&& nglyphs
== 0)
19782 RECORD_MAX_MIN_POS (it
);
19784 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
19785 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
19786 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
19787 row
->phys_height
= max (row
->phys_height
,
19788 it
->max_phys_ascent
+ it
->max_phys_descent
);
19789 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
19790 it
->max_extra_line_spacing
);
19792 /* End of this display line if row is continued. */
19793 if (row
->continued_p
|| row
->ends_at_zv_p
)
19798 /* Is this a line end? If yes, we're also done, after making
19799 sure that a non-default face is extended up to the right
19800 margin of the window. */
19801 if (ITERATOR_AT_END_OF_LINE_P (it
))
19803 int used_before
= row
->used
[TEXT_AREA
];
19805 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
19807 /* Add a space at the end of the line that is used to
19808 display the cursor there. */
19809 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19810 append_space_for_newline (it
, 0);
19812 /* Extend the face to the end of the line. */
19813 extend_face_to_end_of_line (it
);
19815 /* Make sure we have the position. */
19816 if (used_before
== 0)
19817 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
19819 /* Record the position of the newline, for use in
19821 it
->eol_pos
= it
->current
.pos
;
19823 /* Consume the line end. This skips over invisible lines. */
19824 set_iterator_to_next (it
, 1);
19825 it
->continuation_lines_width
= 0;
19829 /* Proceed with next display element. Note that this skips
19830 over lines invisible because of selective display. */
19831 set_iterator_to_next (it
, 1);
19833 /* If we truncate lines, we are done when the last displayed
19834 glyphs reach past the right margin of the window. */
19835 if (it
->line_wrap
== TRUNCATE
19836 && (FRAME_WINDOW_P (it
->f
) && WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
19837 ? (it
->current_x
>= it
->last_visible_x
)
19838 : (it
->current_x
> it
->last_visible_x
)))
19840 /* Maybe add truncation glyphs. */
19841 if (!FRAME_WINDOW_P (it
->f
)
19842 || (row
->reversed_p
19843 ? WINDOW_LEFT_FRINGE_WIDTH (it
->w
)
19844 : WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)) == 0)
19848 if (!row
->reversed_p
)
19850 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
19851 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
19856 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
19857 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
19859 /* Remove any padding glyphs at the front of ROW, to
19860 make room for the truncation glyphs we will be
19861 adding below. The loop below always inserts at
19862 least one truncation glyph, so also remove the
19863 last glyph added to ROW. */
19864 unproduce_glyphs (it
, i
+ 1);
19865 /* Adjust i for the loop below. */
19866 i
= row
->used
[TEXT_AREA
] - (i
+ 1);
19869 it
->current_x
= x_before
;
19870 if (!FRAME_WINDOW_P (it
->f
))
19872 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
19874 row
->used
[TEXT_AREA
] = i
;
19875 produce_special_glyphs (it
, IT_TRUNCATION
);
19880 row
->used
[TEXT_AREA
] = i
;
19881 produce_special_glyphs (it
, IT_TRUNCATION
);
19884 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
19886 /* Don't truncate if we can overflow newline into fringe. */
19887 if (!get_next_display_element (it
))
19889 it
->continuation_lines_width
= 0;
19890 row
->ends_at_zv_p
= 1;
19891 row
->exact_window_width_line_p
= 1;
19894 if (ITERATOR_AT_END_OF_LINE_P (it
))
19896 row
->exact_window_width_line_p
= 1;
19897 goto at_end_of_line
;
19899 it
->current_x
= x_before
;
19902 row
->truncated_on_right_p
= 1;
19903 it
->continuation_lines_width
= 0;
19904 reseat_at_next_visible_line_start (it
, 0);
19905 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
19906 it
->hpos
= hpos_before
;
19912 bidi_unshelve_cache (wrap_data
, 1);
19914 /* If line is not empty and hscrolled, maybe insert truncation glyphs
19915 at the left window margin. */
19916 if (it
->first_visible_x
19917 && IT_CHARPOS (*it
) != CHARPOS (row
->start
.pos
))
19919 if (!FRAME_WINDOW_P (it
->f
)
19920 || (row
->reversed_p
19921 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
19922 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
19923 insert_left_trunc_glyphs (it
);
19924 row
->truncated_on_left_p
= 1;
19927 /* Remember the position at which this line ends.
19929 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
19930 cannot be before the call to find_row_edges below, since that is
19931 where these positions are determined. */
19932 row
->end
= it
->current
;
19935 row
->minpos
= row
->start
.pos
;
19936 row
->maxpos
= row
->end
.pos
;
19940 /* ROW->minpos and ROW->maxpos must be the smallest and
19941 `1 + the largest' buffer positions in ROW. But if ROW was
19942 bidi-reordered, these two positions can be anywhere in the
19943 row, so we must determine them now. */
19944 find_row_edges (it
, row
, min_pos
, min_bpos
, max_pos
, max_bpos
);
19947 /* If the start of this line is the overlay arrow-position, then
19948 mark this glyph row as the one containing the overlay arrow.
19949 This is clearly a mess with variable size fonts. It would be
19950 better to let it be displayed like cursors under X. */
19951 if ((row
->displays_text_p
|| !overlay_arrow_seen
)
19952 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
19953 !NILP (overlay_arrow_string
)))
19955 /* Overlay arrow in window redisplay is a fringe bitmap. */
19956 if (STRINGP (overlay_arrow_string
))
19958 struct glyph_row
*arrow_row
19959 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
19960 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
19961 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
19962 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
19963 struct glyph
*p2
, *end
;
19965 /* Copy the arrow glyphs. */
19966 while (glyph
< arrow_end
)
19969 /* Throw away padding glyphs. */
19971 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
19972 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
19978 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
19983 eassert (INTEGERP (overlay_arrow_string
));
19984 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
19986 overlay_arrow_seen
= 1;
19989 /* Highlight trailing whitespace. */
19990 if (!NILP (Vshow_trailing_whitespace
))
19991 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
19993 /* Compute pixel dimensions of this line. */
19994 compute_line_metrics (it
);
19996 /* Implementation note: No changes in the glyphs of ROW or in their
19997 faces can be done past this point, because compute_line_metrics
19998 computes ROW's hash value and stores it within the glyph_row
20001 /* Record whether this row ends inside an ellipsis. */
20002 row
->ends_in_ellipsis_p
20003 = (it
->method
== GET_FROM_DISPLAY_VECTOR
20004 && it
->ellipsis_p
);
20006 /* Save fringe bitmaps in this row. */
20007 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
20008 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
20009 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
20010 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
20012 it
->left_user_fringe_bitmap
= 0;
20013 it
->left_user_fringe_face_id
= 0;
20014 it
->right_user_fringe_bitmap
= 0;
20015 it
->right_user_fringe_face_id
= 0;
20017 /* Maybe set the cursor. */
20018 cvpos
= it
->w
->cursor
.vpos
;
20020 /* In bidi-reordered rows, keep checking for proper cursor
20021 position even if one has been found already, because buffer
20022 positions in such rows change non-linearly with ROW->VPOS,
20023 when a line is continued. One exception: when we are at ZV,
20024 display cursor on the first suitable glyph row, since all
20025 the empty rows after that also have their position set to ZV. */
20026 /* FIXME: Revisit this when glyph ``spilling'' in continuation
20027 lines' rows is implemented for bidi-reordered rows. */
20029 && !MATRIX_ROW (it
->w
->desired_matrix
, cvpos
)->ends_at_zv_p
))
20030 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
20031 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
20032 && cursor_row_p (row
))
20033 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
20035 /* Prepare for the next line. This line starts horizontally at (X
20036 HPOS) = (0 0). Vertical positions are incremented. As a
20037 convenience for the caller, IT->glyph_row is set to the next
20039 it
->current_x
= it
->hpos
= 0;
20040 it
->current_y
+= row
->height
;
20041 SET_TEXT_POS (it
->eol_pos
, 0, 0);
20044 /* The next row should by default use the same value of the
20045 reversed_p flag as this one. set_iterator_to_next decides when
20046 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
20047 the flag accordingly. */
20048 if (it
->glyph_row
< MATRIX_BOTTOM_TEXT_ROW (it
->w
->desired_matrix
, it
->w
))
20049 it
->glyph_row
->reversed_p
= row
->reversed_p
;
20050 it
->start
= row
->end
;
20051 return row
->displays_text_p
;
20053 #undef RECORD_MAX_MIN_POS
20056 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction
,
20057 Scurrent_bidi_paragraph_direction
, 0, 1, 0,
20058 doc
: /* Return paragraph direction at point in BUFFER.
20059 Value is either `left-to-right' or `right-to-left'.
20060 If BUFFER is omitted or nil, it defaults to the current buffer.
20062 Paragraph direction determines how the text in the paragraph is displayed.
20063 In left-to-right paragraphs, text begins at the left margin of the window
20064 and the reading direction is generally left to right. In right-to-left
20065 paragraphs, text begins at the right margin and is read from right to left.
20067 See also `bidi-paragraph-direction'. */)
20068 (Lisp_Object buffer
)
20070 struct buffer
*buf
= current_buffer
;
20071 struct buffer
*old
= buf
;
20073 if (! NILP (buffer
))
20075 CHECK_BUFFER (buffer
);
20076 buf
= XBUFFER (buffer
);
20079 if (NILP (BVAR (buf
, bidi_display_reordering
))
20080 || NILP (BVAR (buf
, enable_multibyte_characters
))
20081 /* When we are loading loadup.el, the character property tables
20082 needed for bidi iteration are not yet available. */
20083 || !NILP (Vpurify_flag
))
20084 return Qleft_to_right
;
20085 else if (!NILP (BVAR (buf
, bidi_paragraph_direction
)))
20086 return BVAR (buf
, bidi_paragraph_direction
);
20089 /* Determine the direction from buffer text. We could try to
20090 use current_matrix if it is up to date, but this seems fast
20091 enough as it is. */
20092 struct bidi_it itb
;
20093 ptrdiff_t pos
= BUF_PT (buf
);
20094 ptrdiff_t bytepos
= BUF_PT_BYTE (buf
);
20096 void *itb_data
= bidi_shelve_cache ();
20098 set_buffer_temp (buf
);
20099 /* bidi_paragraph_init finds the base direction of the paragraph
20100 by searching forward from paragraph start. We need the base
20101 direction of the current or _previous_ paragraph, so we need
20102 to make sure we are within that paragraph. To that end, find
20103 the previous non-empty line. */
20104 if (pos
>= ZV
&& pos
> BEGV
)
20107 bytepos
= CHAR_TO_BYTE (pos
);
20109 if (fast_looking_at (build_string ("[\f\t ]*\n"),
20110 pos
, bytepos
, ZV
, ZV_BYTE
, Qnil
) > 0)
20112 while ((c
= FETCH_BYTE (bytepos
)) == '\n'
20113 || c
== ' ' || c
== '\t' || c
== '\f')
20115 if (bytepos
<= BEGV_BYTE
)
20120 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos
)))
20123 bidi_init_it (pos
, bytepos
, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb
);
20124 itb
.paragraph_dir
= NEUTRAL_DIR
;
20125 itb
.string
.s
= NULL
;
20126 itb
.string
.lstring
= Qnil
;
20127 itb
.string
.bufpos
= 0;
20128 itb
.string
.unibyte
= 0;
20129 bidi_paragraph_init (NEUTRAL_DIR
, &itb
, 1);
20130 bidi_unshelve_cache (itb_data
, 0);
20131 set_buffer_temp (old
);
20132 switch (itb
.paragraph_dir
)
20135 return Qleft_to_right
;
20138 return Qright_to_left
;
20148 /***********************************************************************
20150 ***********************************************************************/
20152 /* Redisplay the menu bar in the frame for window W.
20154 The menu bar of X frames that don't have X toolkit support is
20155 displayed in a special window W->frame->menu_bar_window.
20157 The menu bar of terminal frames is treated specially as far as
20158 glyph matrices are concerned. Menu bar lines are not part of
20159 windows, so the update is done directly on the frame matrix rows
20160 for the menu bar. */
20163 display_menu_bar (struct window
*w
)
20165 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
20170 /* Don't do all this for graphical frames. */
20172 if (FRAME_W32_P (f
))
20175 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
20181 if (FRAME_NS_P (f
))
20183 #endif /* HAVE_NS */
20185 #ifdef USE_X_TOOLKIT
20186 eassert (!FRAME_WINDOW_P (f
));
20187 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
20188 it
.first_visible_x
= 0;
20189 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
20190 #else /* not USE_X_TOOLKIT */
20191 if (FRAME_WINDOW_P (f
))
20193 /* Menu bar lines are displayed in the desired matrix of the
20194 dummy window menu_bar_window. */
20195 struct window
*menu_w
;
20196 eassert (WINDOWP (f
->menu_bar_window
));
20197 menu_w
= XWINDOW (f
->menu_bar_window
);
20198 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
20200 it
.first_visible_x
= 0;
20201 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
20205 /* This is a TTY frame, i.e. character hpos/vpos are used as
20207 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
20209 it
.first_visible_x
= 0;
20210 it
.last_visible_x
= FRAME_COLS (f
);
20212 #endif /* not USE_X_TOOLKIT */
20214 /* FIXME: This should be controlled by a user option. See the
20215 comments in redisplay_tool_bar and display_mode_line about
20217 it
.paragraph_embedding
= L2R
;
20219 /* Clear all rows of the menu bar. */
20220 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
20222 struct glyph_row
*row
= it
.glyph_row
+ i
;
20223 clear_glyph_row (row
);
20224 row
->enabled_p
= 1;
20225 row
->full_width_p
= 1;
20228 /* Display all items of the menu bar. */
20229 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
20230 for (i
= 0; i
< ASIZE (items
); i
+= 4)
20232 Lisp_Object string
;
20234 /* Stop at nil string. */
20235 string
= AREF (items
, i
+ 1);
20239 /* Remember where item was displayed. */
20240 ASET (items
, i
+ 3, make_number (it
.hpos
));
20242 /* Display the item, pad with one space. */
20243 if (it
.current_x
< it
.last_visible_x
)
20244 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
20245 SCHARS (string
) + 1, 0, 0, -1);
20248 /* Fill out the line with spaces. */
20249 if (it
.current_x
< it
.last_visible_x
)
20250 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
20252 /* Compute the total height of the lines. */
20253 compute_line_metrics (&it
);
20258 /***********************************************************************
20260 ***********************************************************************/
20262 /* Redisplay mode lines in the window tree whose root is WINDOW. If
20263 FORCE is non-zero, redisplay mode lines unconditionally.
20264 Otherwise, redisplay only mode lines that are garbaged. Value is
20265 the number of windows whose mode lines were redisplayed. */
20268 redisplay_mode_lines (Lisp_Object window
, int force
)
20272 while (!NILP (window
))
20274 struct window
*w
= XWINDOW (window
);
20276 if (WINDOWP (w
->hchild
))
20277 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
20278 else if (WINDOWP (w
->vchild
))
20279 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
20281 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
20282 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
20284 struct text_pos lpoint
;
20285 struct buffer
*old
= current_buffer
;
20287 /* Set the window's buffer for the mode line display. */
20288 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
20289 set_buffer_internal_1 (XBUFFER (w
->buffer
));
20291 /* Point refers normally to the selected window. For any
20292 other window, set up appropriate value. */
20293 if (!EQ (window
, selected_window
))
20295 struct text_pos pt
;
20297 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
20298 if (CHARPOS (pt
) < BEGV
)
20299 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
20300 else if (CHARPOS (pt
) > (ZV
- 1))
20301 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
20303 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
20306 /* Display mode lines. */
20307 clear_glyph_matrix (w
->desired_matrix
);
20308 if (display_mode_lines (w
))
20311 w
->must_be_updated_p
= 1;
20314 /* Restore old settings. */
20315 set_buffer_internal_1 (old
);
20316 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
20326 /* Display the mode and/or header line of window W. Value is the
20327 sum number of mode lines and header lines displayed. */
20330 display_mode_lines (struct window
*w
)
20332 Lisp_Object old_selected_window
, old_selected_frame
;
20335 old_selected_frame
= selected_frame
;
20336 selected_frame
= w
->frame
;
20337 old_selected_window
= selected_window
;
20338 XSETWINDOW (selected_window
, w
);
20340 /* These will be set while the mode line specs are processed. */
20341 line_number_displayed
= 0;
20342 wset_column_number_displayed (w
, Qnil
);
20344 if (WINDOW_WANTS_MODELINE_P (w
))
20346 struct window
*sel_w
= XWINDOW (old_selected_window
);
20348 /* Select mode line face based on the real selected window. */
20349 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
20350 BVAR (current_buffer
, mode_line_format
));
20354 if (WINDOW_WANTS_HEADER_LINE_P (w
))
20356 display_mode_line (w
, HEADER_LINE_FACE_ID
,
20357 BVAR (current_buffer
, header_line_format
));
20361 selected_frame
= old_selected_frame
;
20362 selected_window
= old_selected_window
;
20367 /* Display mode or header line of window W. FACE_ID specifies which
20368 line to display; it is either MODE_LINE_FACE_ID or
20369 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
20370 display. Value is the pixel height of the mode/header line
20374 display_mode_line (struct window
*w
, enum face_id face_id
, Lisp_Object format
)
20378 ptrdiff_t count
= SPECPDL_INDEX ();
20380 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
20381 /* Don't extend on a previously drawn mode-line.
20382 This may happen if called from pos_visible_p. */
20383 it
.glyph_row
->enabled_p
= 0;
20384 prepare_desired_row (it
.glyph_row
);
20386 it
.glyph_row
->mode_line_p
= 1;
20388 /* FIXME: This should be controlled by a user option. But
20389 supporting such an option is not trivial, since the mode line is
20390 made up of many separate strings. */
20391 it
.paragraph_embedding
= L2R
;
20393 record_unwind_protect (unwind_format_mode_line
,
20394 format_mode_line_unwind_data (NULL
, NULL
, Qnil
, 0));
20396 mode_line_target
= MODE_LINE_DISPLAY
;
20398 /* Temporarily make frame's keyboard the current kboard so that
20399 kboard-local variables in the mode_line_format will get the right
20401 push_kboard (FRAME_KBOARD (it
.f
));
20402 record_unwind_save_match_data ();
20403 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
20406 unbind_to (count
, Qnil
);
20408 /* Fill up with spaces. */
20409 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
20411 compute_line_metrics (&it
);
20412 it
.glyph_row
->full_width_p
= 1;
20413 it
.glyph_row
->continued_p
= 0;
20414 it
.glyph_row
->truncated_on_left_p
= 0;
20415 it
.glyph_row
->truncated_on_right_p
= 0;
20417 /* Make a 3D mode-line have a shadow at its right end. */
20418 face
= FACE_FROM_ID (it
.f
, face_id
);
20419 extend_face_to_end_of_line (&it
);
20420 if (face
->box
!= FACE_NO_BOX
)
20422 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
20423 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
20424 last
->right_box_line_p
= 1;
20427 return it
.glyph_row
->height
;
20430 /* Move element ELT in LIST to the front of LIST.
20431 Return the updated list. */
20434 move_elt_to_front (Lisp_Object elt
, Lisp_Object list
)
20436 register Lisp_Object tail
, prev
;
20437 register Lisp_Object tem
;
20441 while (CONSP (tail
))
20447 /* Splice out the link TAIL. */
20449 list
= XCDR (tail
);
20451 Fsetcdr (prev
, XCDR (tail
));
20453 /* Now make it the first. */
20454 Fsetcdr (tail
, list
);
20459 tail
= XCDR (tail
);
20463 /* Not found--return unchanged LIST. */
20467 /* Contribute ELT to the mode line for window IT->w. How it
20468 translates into text depends on its data type.
20470 IT describes the display environment in which we display, as usual.
20472 DEPTH is the depth in recursion. It is used to prevent
20473 infinite recursion here.
20475 FIELD_WIDTH is the number of characters the display of ELT should
20476 occupy in the mode line, and PRECISION is the maximum number of
20477 characters to display from ELT's representation. See
20478 display_string for details.
20480 Returns the hpos of the end of the text generated by ELT.
20482 PROPS is a property list to add to any string we encounter.
20484 If RISKY is nonzero, remove (disregard) any properties in any string
20485 we encounter, and ignore :eval and :propertize.
20487 The global variable `mode_line_target' determines whether the
20488 output is passed to `store_mode_line_noprop',
20489 `store_mode_line_string', or `display_string'. */
20492 display_mode_element (struct it
*it
, int depth
, int field_width
, int precision
,
20493 Lisp_Object elt
, Lisp_Object props
, int risky
)
20495 int n
= 0, field
, prec
;
20500 elt
= build_string ("*too-deep*");
20504 switch (XTYPE (elt
))
20508 /* A string: output it and check for %-constructs within it. */
20510 ptrdiff_t offset
= 0;
20512 if (SCHARS (elt
) > 0
20513 && (!NILP (props
) || risky
))
20515 Lisp_Object oprops
, aelt
;
20516 oprops
= Ftext_properties_at (make_number (0), elt
);
20518 /* If the starting string's properties are not what
20519 we want, translate the string. Also, if the string
20520 is risky, do that anyway. */
20522 if (NILP (Fequal (props
, oprops
)) || risky
)
20524 /* If the starting string has properties,
20525 merge the specified ones onto the existing ones. */
20526 if (! NILP (oprops
) && !risky
)
20530 oprops
= Fcopy_sequence (oprops
);
20532 while (CONSP (tem
))
20534 oprops
= Fplist_put (oprops
, XCAR (tem
),
20535 XCAR (XCDR (tem
)));
20536 tem
= XCDR (XCDR (tem
));
20541 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
20542 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
20544 /* AELT is what we want. Move it to the front
20545 without consing. */
20547 mode_line_proptrans_alist
20548 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
20554 /* If AELT has the wrong props, it is useless.
20555 so get rid of it. */
20557 mode_line_proptrans_alist
20558 = Fdelq (aelt
, mode_line_proptrans_alist
);
20560 elt
= Fcopy_sequence (elt
);
20561 Fset_text_properties (make_number (0), Flength (elt
),
20563 /* Add this item to mode_line_proptrans_alist. */
20564 mode_line_proptrans_alist
20565 = Fcons (Fcons (elt
, props
),
20566 mode_line_proptrans_alist
);
20567 /* Truncate mode_line_proptrans_alist
20568 to at most 50 elements. */
20569 tem
= Fnthcdr (make_number (50),
20570 mode_line_proptrans_alist
);
20572 XSETCDR (tem
, Qnil
);
20581 prec
= precision
- n
;
20582 switch (mode_line_target
)
20584 case MODE_LINE_NOPROP
:
20585 case MODE_LINE_TITLE
:
20586 n
+= store_mode_line_noprop (SSDATA (elt
), -1, prec
);
20588 case MODE_LINE_STRING
:
20589 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
20591 case MODE_LINE_DISPLAY
:
20592 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
20593 0, prec
, 0, STRING_MULTIBYTE (elt
));
20600 /* Handle the non-literal case. */
20602 while ((precision
<= 0 || n
< precision
)
20603 && SREF (elt
, offset
) != 0
20604 && (mode_line_target
!= MODE_LINE_DISPLAY
20605 || it
->current_x
< it
->last_visible_x
))
20607 ptrdiff_t last_offset
= offset
;
20609 /* Advance to end of string or next format specifier. */
20610 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
20613 if (offset
- 1 != last_offset
)
20615 ptrdiff_t nchars
, nbytes
;
20617 /* Output to end of string or up to '%'. Field width
20618 is length of string. Don't output more than
20619 PRECISION allows us. */
20622 prec
= c_string_width (SDATA (elt
) + last_offset
,
20623 offset
- last_offset
, precision
- n
,
20626 switch (mode_line_target
)
20628 case MODE_LINE_NOPROP
:
20629 case MODE_LINE_TITLE
:
20630 n
+= store_mode_line_noprop (SSDATA (elt
) + last_offset
, 0, prec
);
20632 case MODE_LINE_STRING
:
20634 ptrdiff_t bytepos
= last_offset
;
20635 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
20636 ptrdiff_t endpos
= (precision
<= 0
20637 ? string_byte_to_char (elt
, offset
)
20638 : charpos
+ nchars
);
20640 n
+= store_mode_line_string (NULL
,
20641 Fsubstring (elt
, make_number (charpos
),
20642 make_number (endpos
)),
20646 case MODE_LINE_DISPLAY
:
20648 ptrdiff_t bytepos
= last_offset
;
20649 ptrdiff_t charpos
= string_byte_to_char (elt
, bytepos
);
20651 if (precision
<= 0)
20652 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
20653 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
20655 STRING_MULTIBYTE (elt
));
20660 else /* c == '%' */
20662 ptrdiff_t percent_position
= offset
;
20664 /* Get the specified minimum width. Zero means
20667 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
20668 field
= field
* 10 + c
- '0';
20670 /* Don't pad beyond the total padding allowed. */
20671 if (field_width
- n
> 0 && field
> field_width
- n
)
20672 field
= field_width
- n
;
20674 /* Note that either PRECISION <= 0 or N < PRECISION. */
20675 prec
= precision
- n
;
20678 n
+= display_mode_element (it
, depth
, field
, prec
,
20679 Vglobal_mode_string
, props
,
20684 ptrdiff_t bytepos
, charpos
;
20686 Lisp_Object string
;
20688 bytepos
= percent_position
;
20689 charpos
= (STRING_MULTIBYTE (elt
)
20690 ? string_byte_to_char (elt
, bytepos
)
20692 spec
= decode_mode_spec (it
->w
, c
, field
, &string
);
20693 multibyte
= STRINGP (string
) && STRING_MULTIBYTE (string
);
20695 switch (mode_line_target
)
20697 case MODE_LINE_NOPROP
:
20698 case MODE_LINE_TITLE
:
20699 n
+= store_mode_line_noprop (spec
, field
, prec
);
20701 case MODE_LINE_STRING
:
20703 Lisp_Object tem
= build_string (spec
);
20704 props
= Ftext_properties_at (make_number (charpos
), elt
);
20705 /* Should only keep face property in props */
20706 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
20709 case MODE_LINE_DISPLAY
:
20711 int nglyphs_before
, nwritten
;
20713 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
20714 nwritten
= display_string (spec
, string
, elt
,
20719 /* Assign to the glyphs written above the
20720 string where the `%x' came from, position
20724 struct glyph
*glyph
20725 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
20729 for (i
= 0; i
< nwritten
; ++i
)
20731 glyph
[i
].object
= elt
;
20732 glyph
[i
].charpos
= charpos
;
20749 /* A symbol: process the value of the symbol recursively
20750 as if it appeared here directly. Avoid error if symbol void.
20751 Special case: if value of symbol is a string, output the string
20754 register Lisp_Object tem
;
20756 /* If the variable is not marked as risky to set
20757 then its contents are risky to use. */
20758 if (NILP (Fget (elt
, Qrisky_local_variable
)))
20761 tem
= Fboundp (elt
);
20764 tem
= Fsymbol_value (elt
);
20765 /* If value is a string, output that string literally:
20766 don't check for % within it. */
20770 if (!EQ (tem
, elt
))
20772 /* Give up right away for nil or t. */
20782 register Lisp_Object car
, tem
;
20784 /* A cons cell: five distinct cases.
20785 If first element is :eval or :propertize, do something special.
20786 If first element is a string or a cons, process all the elements
20787 and effectively concatenate them.
20788 If first element is a negative number, truncate displaying cdr to
20789 at most that many characters. If positive, pad (with spaces)
20790 to at least that many characters.
20791 If first element is a symbol, process the cadr or caddr recursively
20792 according to whether the symbol's value is non-nil or nil. */
20794 if (EQ (car
, QCeval
))
20796 /* An element of the form (:eval FORM) means evaluate FORM
20797 and use the result as mode line elements. */
20802 if (CONSP (XCDR (elt
)))
20805 spec
= safe_eval (XCAR (XCDR (elt
)));
20806 n
+= display_mode_element (it
, depth
, field_width
- n
,
20807 precision
- n
, spec
, props
,
20811 else if (EQ (car
, QCpropertize
))
20813 /* An element of the form (:propertize ELT PROPS...)
20814 means display ELT but applying properties PROPS. */
20819 if (CONSP (XCDR (elt
)))
20820 n
+= display_mode_element (it
, depth
, field_width
- n
,
20821 precision
- n
, XCAR (XCDR (elt
)),
20822 XCDR (XCDR (elt
)), risky
);
20824 else if (SYMBOLP (car
))
20826 tem
= Fboundp (car
);
20830 /* elt is now the cdr, and we know it is a cons cell.
20831 Use its car if CAR has a non-nil value. */
20834 tem
= Fsymbol_value (car
);
20841 /* Symbol's value is nil (or symbol is unbound)
20842 Get the cddr of the original list
20843 and if possible find the caddr and use that. */
20847 else if (!CONSP (elt
))
20852 else if (INTEGERP (car
))
20854 register int lim
= XINT (car
);
20858 /* Negative int means reduce maximum width. */
20859 if (precision
<= 0)
20862 precision
= min (precision
, -lim
);
20866 /* Padding specified. Don't let it be more than
20867 current maximum. */
20869 lim
= min (precision
, lim
);
20871 /* If that's more padding than already wanted, queue it.
20872 But don't reduce padding already specified even if
20873 that is beyond the current truncation point. */
20874 field_width
= max (lim
, field_width
);
20878 else if (STRINGP (car
) || CONSP (car
))
20880 Lisp_Object halftail
= elt
;
20884 && (precision
<= 0 || n
< precision
))
20886 n
+= display_mode_element (it
, depth
,
20887 /* Do padding only after the last
20888 element in the list. */
20889 (! CONSP (XCDR (elt
))
20892 precision
- n
, XCAR (elt
),
20896 if ((len
& 1) == 0)
20897 halftail
= XCDR (halftail
);
20898 /* Check for cycle. */
20899 if (EQ (halftail
, elt
))
20908 elt
= build_string ("*invalid*");
20912 /* Pad to FIELD_WIDTH. */
20913 if (field_width
> 0 && n
< field_width
)
20915 switch (mode_line_target
)
20917 case MODE_LINE_NOPROP
:
20918 case MODE_LINE_TITLE
:
20919 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
20921 case MODE_LINE_STRING
:
20922 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
20924 case MODE_LINE_DISPLAY
:
20925 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
20934 /* Store a mode-line string element in mode_line_string_list.
20936 If STRING is non-null, display that C string. Otherwise, the Lisp
20937 string LISP_STRING is displayed.
20939 FIELD_WIDTH is the minimum number of output glyphs to produce.
20940 If STRING has fewer characters than FIELD_WIDTH, pad to the right
20941 with spaces. FIELD_WIDTH <= 0 means don't pad.
20943 PRECISION is the maximum number of characters to output from
20944 STRING. PRECISION <= 0 means don't truncate the string.
20946 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
20947 properties to the string.
20949 PROPS are the properties to add to the string.
20950 The mode_line_string_face face property is always added to the string.
20954 store_mode_line_string (const char *string
, Lisp_Object lisp_string
, int copy_string
,
20955 int field_width
, int precision
, Lisp_Object props
)
20960 if (string
!= NULL
)
20962 len
= strlen (string
);
20963 if (precision
> 0 && len
> precision
)
20965 lisp_string
= make_string (string
, len
);
20967 props
= mode_line_string_face_prop
;
20968 else if (!NILP (mode_line_string_face
))
20970 Lisp_Object face
= Fplist_get (props
, Qface
);
20971 props
= Fcopy_sequence (props
);
20973 face
= mode_line_string_face
;
20975 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
20976 props
= Fplist_put (props
, Qface
, face
);
20978 Fadd_text_properties (make_number (0), make_number (len
),
20979 props
, lisp_string
);
20983 len
= XFASTINT (Flength (lisp_string
));
20984 if (precision
> 0 && len
> precision
)
20987 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
20990 if (!NILP (mode_line_string_face
))
20994 props
= Ftext_properties_at (make_number (0), lisp_string
);
20995 face
= Fplist_get (props
, Qface
);
20997 face
= mode_line_string_face
;
20999 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
21000 props
= Fcons (Qface
, Fcons (face
, Qnil
));
21002 lisp_string
= Fcopy_sequence (lisp_string
);
21005 Fadd_text_properties (make_number (0), make_number (len
),
21006 props
, lisp_string
);
21011 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
21015 if (field_width
> len
)
21017 field_width
-= len
;
21018 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
21020 Fadd_text_properties (make_number (0), make_number (field_width
),
21021 props
, lisp_string
);
21022 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
21030 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
21032 doc
: /* Format a string out of a mode line format specification.
21033 First arg FORMAT specifies the mode line format (see `mode-line-format'
21034 for details) to use.
21036 By default, the format is evaluated for the currently selected window.
21038 Optional second arg FACE specifies the face property to put on all
21039 characters for which no face is specified. The value nil means the
21040 default face. The value t means whatever face the window's mode line
21041 currently uses (either `mode-line' or `mode-line-inactive',
21042 depending on whether the window is the selected window or not).
21043 An integer value means the value string has no text
21046 Optional third and fourth args WINDOW and BUFFER specify the window
21047 and buffer to use as the context for the formatting (defaults
21048 are the selected window and the WINDOW's buffer). */)
21049 (Lisp_Object format
, Lisp_Object face
,
21050 Lisp_Object window
, Lisp_Object buffer
)
21055 struct buffer
*old_buffer
= NULL
;
21057 int no_props
= INTEGERP (face
);
21058 ptrdiff_t count
= SPECPDL_INDEX ();
21060 int string_start
= 0;
21062 w
= decode_any_window (window
);
21063 XSETWINDOW (window
, w
);
21066 buffer
= w
->buffer
;
21067 CHECK_BUFFER (buffer
);
21069 /* Make formatting the modeline a non-op when noninteractive, otherwise
21070 there will be problems later caused by a partially initialized frame. */
21071 if (NILP (format
) || noninteractive
)
21072 return empty_unibyte_string
;
21077 face_id
= (NILP (face
) || EQ (face
, Qdefault
)) ? DEFAULT_FACE_ID
21078 : EQ (face
, Qt
) ? (EQ (window
, selected_window
)
21079 ? MODE_LINE_FACE_ID
: MODE_LINE_INACTIVE_FACE_ID
)
21080 : EQ (face
, Qmode_line
) ? MODE_LINE_FACE_ID
21081 : EQ (face
, Qmode_line_inactive
) ? MODE_LINE_INACTIVE_FACE_ID
21082 : EQ (face
, Qheader_line
) ? HEADER_LINE_FACE_ID
21083 : EQ (face
, Qtool_bar
) ? TOOL_BAR_FACE_ID
21086 old_buffer
= current_buffer
;
21088 /* Save things including mode_line_proptrans_alist,
21089 and set that to nil so that we don't alter the outer value. */
21090 record_unwind_protect (unwind_format_mode_line
,
21091 format_mode_line_unwind_data
21092 (XFRAME (WINDOW_FRAME (w
)),
21093 old_buffer
, selected_window
, 1));
21094 mode_line_proptrans_alist
= Qnil
;
21096 Fselect_window (window
, Qt
);
21097 set_buffer_internal_1 (XBUFFER (buffer
));
21099 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
21103 mode_line_target
= MODE_LINE_NOPROP
;
21104 mode_line_string_face_prop
= Qnil
;
21105 mode_line_string_list
= Qnil
;
21106 string_start
= MODE_LINE_NOPROP_LEN (0);
21110 mode_line_target
= MODE_LINE_STRING
;
21111 mode_line_string_list
= Qnil
;
21112 mode_line_string_face
= face
;
21113 mode_line_string_face_prop
21114 = (NILP (face
) ? Qnil
: Fcons (Qface
, Fcons (face
, Qnil
)));
21117 push_kboard (FRAME_KBOARD (it
.f
));
21118 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
21123 len
= MODE_LINE_NOPROP_LEN (string_start
);
21124 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
21128 mode_line_string_list
= Fnreverse (mode_line_string_list
);
21129 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
21130 empty_unibyte_string
);
21133 unbind_to (count
, Qnil
);
21137 /* Write a null-terminated, right justified decimal representation of
21138 the positive integer D to BUF using a minimal field width WIDTH. */
21141 pint2str (register char *buf
, register int width
, register ptrdiff_t d
)
21143 register char *p
= buf
;
21151 *p
++ = d
% 10 + '0';
21156 for (width
-= (int) (p
- buf
); width
> 0; --width
)
21167 /* Write a null-terminated, right justified decimal and "human
21168 readable" representation of the nonnegative integer D to BUF using
21169 a minimal field width WIDTH. D should be smaller than 999.5e24. */
21171 static const char power_letter
[] =
21185 pint2hrstr (char *buf
, int width
, ptrdiff_t d
)
21187 /* We aim to represent the nonnegative integer D as
21188 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
21189 ptrdiff_t quotient
= d
;
21191 /* -1 means: do not use TENTHS. */
21195 /* Length of QUOTIENT.TENTHS as a string. */
21201 if (1000 <= quotient
)
21203 /* Scale to the appropriate EXPONENT. */
21206 remainder
= quotient
% 1000;
21210 while (1000 <= quotient
);
21212 /* Round to nearest and decide whether to use TENTHS or not. */
21215 tenths
= remainder
/ 100;
21216 if (50 <= remainder
% 100)
21223 if (quotient
== 10)
21231 if (500 <= remainder
)
21233 if (quotient
< 999)
21244 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
21245 if (tenths
== -1 && quotient
<= 99)
21252 p
= psuffix
= buf
+ max (width
, length
);
21254 /* Print EXPONENT. */
21255 *psuffix
++ = power_letter
[exponent
];
21258 /* Print TENTHS. */
21261 *--p
= '0' + tenths
;
21265 /* Print QUOTIENT. */
21268 int digit
= quotient
% 10;
21269 *--p
= '0' + digit
;
21271 while ((quotient
/= 10) != 0);
21273 /* Print leading spaces. */
21278 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
21279 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
21280 type of CODING_SYSTEM. Return updated pointer into BUF. */
21282 static unsigned char invalid_eol_type
[] = "(*invalid*)";
21285 decode_mode_spec_coding (Lisp_Object coding_system
, register char *buf
, int eol_flag
)
21288 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
21289 const unsigned char *eol_str
;
21291 /* The EOL conversion we are using. */
21292 Lisp_Object eoltype
;
21294 val
= CODING_SYSTEM_SPEC (coding_system
);
21297 if (!VECTORP (val
)) /* Not yet decided. */
21299 *buf
++ = multibyte
? '-' : ' ';
21301 eoltype
= eol_mnemonic_undecided
;
21302 /* Don't mention EOL conversion if it isn't decided. */
21307 Lisp_Object eolvalue
;
21309 attrs
= AREF (val
, 0);
21310 eolvalue
= AREF (val
, 2);
21313 ? XFASTINT (CODING_ATTR_MNEMONIC (attrs
))
21318 /* The EOL conversion that is normal on this system. */
21320 if (NILP (eolvalue
)) /* Not yet decided. */
21321 eoltype
= eol_mnemonic_undecided
;
21322 else if (VECTORP (eolvalue
)) /* Not yet decided. */
21323 eoltype
= eol_mnemonic_undecided
;
21324 else /* eolvalue is Qunix, Qdos, or Qmac. */
21325 eoltype
= (EQ (eolvalue
, Qunix
)
21326 ? eol_mnemonic_unix
21327 : (EQ (eolvalue
, Qdos
) == 1
21328 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
21334 /* Mention the EOL conversion if it is not the usual one. */
21335 if (STRINGP (eoltype
))
21337 eol_str
= SDATA (eoltype
);
21338 eol_str_len
= SBYTES (eoltype
);
21340 else if (CHARACTERP (eoltype
))
21342 unsigned char *tmp
= alloca (MAX_MULTIBYTE_LENGTH
);
21343 int c
= XFASTINT (eoltype
);
21344 eol_str_len
= CHAR_STRING (c
, tmp
);
21349 eol_str
= invalid_eol_type
;
21350 eol_str_len
= sizeof (invalid_eol_type
) - 1;
21352 memcpy (buf
, eol_str
, eol_str_len
);
21353 buf
+= eol_str_len
;
21359 /* Return a string for the output of a mode line %-spec for window W,
21360 generated by character C. FIELD_WIDTH > 0 means pad the string
21361 returned with spaces to that value. Return a Lisp string in
21362 *STRING if the resulting string is taken from that Lisp string.
21364 Note we operate on the current buffer for most purposes,
21365 the exception being w->base_line_pos. */
21367 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
21369 static const char *
21370 decode_mode_spec (struct window
*w
, register int c
, int field_width
,
21371 Lisp_Object
*string
)
21374 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
21375 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
21376 /* We are going to use f->decode_mode_spec_buffer as the buffer to
21377 produce strings from numerical values, so limit preposterously
21378 large values of FIELD_WIDTH to avoid overrunning the buffer's
21379 end. The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
21380 bytes plus the terminating null. */
21381 int width
= min (field_width
, FRAME_MESSAGE_BUF_SIZE (f
));
21382 struct buffer
*b
= current_buffer
;
21390 if (!NILP (BVAR (b
, read_only
)))
21392 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21397 /* This differs from %* only for a modified read-only buffer. */
21398 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21400 if (!NILP (BVAR (b
, read_only
)))
21405 /* This differs from %* in ignoring read-only-ness. */
21406 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
21418 if (command_loop_level
> 5)
21420 p
= decode_mode_spec_buf
;
21421 for (i
= 0; i
< command_loop_level
; i
++)
21424 return decode_mode_spec_buf
;
21432 if (command_loop_level
> 5)
21434 p
= decode_mode_spec_buf
;
21435 for (i
= 0; i
< command_loop_level
; i
++)
21438 return decode_mode_spec_buf
;
21445 /* Let lots_of_dashes be a string of infinite length. */
21446 if (mode_line_target
== MODE_LINE_NOPROP
||
21447 mode_line_target
== MODE_LINE_STRING
)
21449 if (field_width
<= 0
21450 || field_width
> sizeof (lots_of_dashes
))
21452 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
21453 decode_mode_spec_buf
[i
] = '-';
21454 decode_mode_spec_buf
[i
] = '\0';
21455 return decode_mode_spec_buf
;
21458 return lots_of_dashes
;
21462 obj
= BVAR (b
, name
);
21466 /* %c and %l are ignored in `frame-title-format'.
21467 (In redisplay_internal, the frame title is drawn _before_ the
21468 windows are updated, so the stuff which depends on actual
21469 window contents (such as %l) may fail to render properly, or
21470 even crash emacs.) */
21471 if (mode_line_target
== MODE_LINE_TITLE
)
21475 ptrdiff_t col
= current_column ();
21476 wset_column_number_displayed (w
, make_number (col
));
21477 pint2str (decode_mode_spec_buf
, width
, col
);
21478 return decode_mode_spec_buf
;
21482 #ifndef SYSTEM_MALLOC
21484 if (NILP (Vmemory_full
))
21487 return "!MEM FULL! ";
21494 /* %F displays the frame name. */
21495 if (!NILP (f
->title
))
21496 return SSDATA (f
->title
);
21497 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
21498 return SSDATA (f
->name
);
21502 obj
= BVAR (b
, filename
);
21507 ptrdiff_t size
= ZV
- BEGV
;
21508 pint2str (decode_mode_spec_buf
, width
, size
);
21509 return decode_mode_spec_buf
;
21514 ptrdiff_t size
= ZV
- BEGV
;
21515 pint2hrstr (decode_mode_spec_buf
, width
, size
);
21516 return decode_mode_spec_buf
;
21521 ptrdiff_t startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
21522 ptrdiff_t topline
, nlines
, height
;
21525 /* %c and %l are ignored in `frame-title-format'. */
21526 if (mode_line_target
== MODE_LINE_TITLE
)
21529 startpos
= XMARKER (w
->start
)->charpos
;
21530 startpos_byte
= marker_byte_position (w
->start
);
21531 height
= WINDOW_TOTAL_LINES (w
);
21533 /* If we decided that this buffer isn't suitable for line numbers,
21534 don't forget that too fast. */
21535 if (EQ (w
->base_line_pos
, w
->buffer
))
21537 /* But do forget it, if the window shows a different buffer now. */
21538 else if (BUFFERP (w
->base_line_pos
))
21539 wset_base_line_pos (w
, Qnil
);
21541 /* If the buffer is very big, don't waste time. */
21542 if (INTEGERP (Vline_number_display_limit
)
21543 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
21545 wset_base_line_pos (w
, Qnil
);
21546 wset_base_line_number (w
, Qnil
);
21550 if (INTEGERP (w
->base_line_number
)
21551 && INTEGERP (w
->base_line_pos
)
21552 && XFASTINT (w
->base_line_pos
) <= startpos
)
21554 line
= XFASTINT (w
->base_line_number
);
21555 linepos
= XFASTINT (w
->base_line_pos
);
21556 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
21561 linepos
= BUF_BEGV (b
);
21562 linepos_byte
= BUF_BEGV_BYTE (b
);
21565 /* Count lines from base line to window start position. */
21566 nlines
= display_count_lines (linepos_byte
,
21570 topline
= nlines
+ line
;
21572 /* Determine a new base line, if the old one is too close
21573 or too far away, or if we did not have one.
21574 "Too close" means it's plausible a scroll-down would
21575 go back past it. */
21576 if (startpos
== BUF_BEGV (b
))
21578 wset_base_line_number (w
, make_number (topline
));
21579 wset_base_line_pos (w
, make_number (BUF_BEGV (b
)));
21581 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
21582 || linepos
== BUF_BEGV (b
))
21584 ptrdiff_t limit
= BUF_BEGV (b
);
21585 ptrdiff_t limit_byte
= BUF_BEGV_BYTE (b
);
21586 ptrdiff_t position
;
21587 ptrdiff_t distance
=
21588 (height
* 2 + 30) * line_number_display_limit_width
;
21590 if (startpos
- distance
> limit
)
21592 limit
= startpos
- distance
;
21593 limit_byte
= CHAR_TO_BYTE (limit
);
21596 nlines
= display_count_lines (startpos_byte
,
21598 - (height
* 2 + 30),
21600 /* If we couldn't find the lines we wanted within
21601 line_number_display_limit_width chars per line,
21602 give up on line numbers for this window. */
21603 if (position
== limit_byte
&& limit
== startpos
- distance
)
21605 wset_base_line_pos (w
, w
->buffer
);
21606 wset_base_line_number (w
, Qnil
);
21610 wset_base_line_number (w
, make_number (topline
- nlines
));
21611 wset_base_line_pos (w
, make_number (BYTE_TO_CHAR (position
)));
21614 /* Now count lines from the start pos to point. */
21615 nlines
= display_count_lines (startpos_byte
,
21616 PT_BYTE
, PT
, &junk
);
21618 /* Record that we did display the line number. */
21619 line_number_displayed
= 1;
21621 /* Make the string to show. */
21622 pint2str (decode_mode_spec_buf
, width
, topline
+ nlines
);
21623 return decode_mode_spec_buf
;
21626 char* p
= decode_mode_spec_buf
;
21627 int pad
= width
- 2;
21633 return decode_mode_spec_buf
;
21639 obj
= BVAR (b
, mode_name
);
21643 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
21649 ptrdiff_t pos
= marker_position (w
->start
);
21650 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
21652 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
21654 if (pos
<= BUF_BEGV (b
))
21659 else if (pos
<= BUF_BEGV (b
))
21663 if (total
> 1000000)
21664 /* Do it differently for a large value, to avoid overflow. */
21665 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
21667 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
21668 /* We can't normally display a 3-digit number,
21669 so get us a 2-digit number that is close. */
21672 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
21673 return decode_mode_spec_buf
;
21677 /* Display percentage of size above the bottom of the screen. */
21680 ptrdiff_t toppos
= marker_position (w
->start
);
21681 ptrdiff_t botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
21682 ptrdiff_t total
= BUF_ZV (b
) - BUF_BEGV (b
);
21684 if (botpos
>= BUF_ZV (b
))
21686 if (toppos
<= BUF_BEGV (b
))
21693 if (total
> 1000000)
21694 /* Do it differently for a large value, to avoid overflow. */
21695 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
21697 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
21698 /* We can't normally display a 3-digit number,
21699 so get us a 2-digit number that is close. */
21702 if (toppos
<= BUF_BEGV (b
))
21703 sprintf (decode_mode_spec_buf
, "Top%2"pD
"d%%", total
);
21705 sprintf (decode_mode_spec_buf
, "%2"pD
"d%%", total
);
21706 return decode_mode_spec_buf
;
21711 /* status of process */
21712 obj
= Fget_buffer_process (Fcurrent_buffer ());
21714 return "no process";
21716 obj
= Fsymbol_name (Fprocess_status (obj
));
21722 ptrdiff_t count
= inhibit_garbage_collection ();
21723 Lisp_Object val
= call1 (intern ("file-remote-p"),
21724 BVAR (current_buffer
, directory
));
21725 unbind_to (count
, Qnil
);
21733 case 't': /* indicate TEXT or BINARY */
21737 /* coding-system (not including end-of-line format) */
21739 /* coding-system (including end-of-line type) */
21741 int eol_flag
= (c
== 'Z');
21742 char *p
= decode_mode_spec_buf
;
21744 if (! FRAME_WINDOW_P (f
))
21746 /* No need to mention EOL here--the terminal never needs
21747 to do EOL conversion. */
21748 p
= decode_mode_spec_coding (CODING_ID_NAME
21749 (FRAME_KEYBOARD_CODING (f
)->id
),
21751 p
= decode_mode_spec_coding (CODING_ID_NAME
21752 (FRAME_TERMINAL_CODING (f
)->id
),
21755 p
= decode_mode_spec_coding (BVAR (b
, buffer_file_coding_system
),
21758 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
21759 #ifdef subprocesses
21760 obj
= Fget_buffer_process (Fcurrent_buffer ());
21761 if (PROCESSP (obj
))
21763 p
= decode_mode_spec_coding
21764 (XPROCESS (obj
)->decode_coding_system
, p
, eol_flag
);
21765 p
= decode_mode_spec_coding
21766 (XPROCESS (obj
)->encode_coding_system
, p
, eol_flag
);
21768 #endif /* subprocesses */
21771 return decode_mode_spec_buf
;
21778 return SSDATA (obj
);
21785 /* Count up to COUNT lines starting from START_BYTE.
21786 But don't go beyond LIMIT_BYTE.
21787 Return the number of lines thus found (always nonnegative).
21789 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
21792 display_count_lines (ptrdiff_t start_byte
,
21793 ptrdiff_t limit_byte
, ptrdiff_t count
,
21794 ptrdiff_t *byte_pos_ptr
)
21796 register unsigned char *cursor
;
21797 unsigned char *base
;
21799 register ptrdiff_t ceiling
;
21800 register unsigned char *ceiling_addr
;
21801 ptrdiff_t orig_count
= count
;
21803 /* If we are not in selective display mode,
21804 check only for newlines. */
21805 int selective_display
= (!NILP (BVAR (current_buffer
, selective_display
))
21806 && !INTEGERP (BVAR (current_buffer
, selective_display
)));
21810 while (start_byte
< limit_byte
)
21812 ceiling
= BUFFER_CEILING_OF (start_byte
);
21813 ceiling
= min (limit_byte
- 1, ceiling
);
21814 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
21815 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
21818 if (selective_display
)
21819 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
21822 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
21825 if (cursor
!= ceiling_addr
)
21829 start_byte
+= cursor
- base
+ 1;
21830 *byte_pos_ptr
= start_byte
;
21834 if (++cursor
== ceiling_addr
)
21840 start_byte
+= cursor
- base
;
21845 while (start_byte
> limit_byte
)
21847 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
21848 ceiling
= max (limit_byte
, ceiling
);
21849 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
21850 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
21853 if (selective_display
)
21854 while (--cursor
!= ceiling_addr
21855 && *cursor
!= '\n' && *cursor
!= 015)
21858 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
21861 if (cursor
!= ceiling_addr
)
21865 start_byte
+= cursor
- base
+ 1;
21866 *byte_pos_ptr
= start_byte
;
21867 /* When scanning backwards, we should
21868 not count the newline posterior to which we stop. */
21869 return - orig_count
- 1;
21875 /* Here we add 1 to compensate for the last decrement
21876 of CURSOR, which took it past the valid range. */
21877 start_byte
+= cursor
- base
+ 1;
21881 *byte_pos_ptr
= limit_byte
;
21884 return - orig_count
+ count
;
21885 return orig_count
- count
;
21891 /***********************************************************************
21893 ***********************************************************************/
21895 /* Display a NUL-terminated string, starting with index START.
21897 If STRING is non-null, display that C string. Otherwise, the Lisp
21898 string LISP_STRING is displayed. There's a case that STRING is
21899 non-null and LISP_STRING is not nil. It means STRING is a string
21900 data of LISP_STRING. In that case, we display LISP_STRING while
21901 ignoring its text properties.
21903 If FACE_STRING is not nil, FACE_STRING_POS is a position in
21904 FACE_STRING. Display STRING or LISP_STRING with the face at
21905 FACE_STRING_POS in FACE_STRING:
21907 Display the string in the environment given by IT, but use the
21908 standard display table, temporarily.
21910 FIELD_WIDTH is the minimum number of output glyphs to produce.
21911 If STRING has fewer characters than FIELD_WIDTH, pad to the right
21912 with spaces. If STRING has more characters, more than FIELD_WIDTH
21913 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
21915 PRECISION is the maximum number of characters to output from
21916 STRING. PRECISION < 0 means don't truncate the string.
21918 This is roughly equivalent to printf format specifiers:
21920 FIELD_WIDTH PRECISION PRINTF
21921 ----------------------------------------
21927 MULTIBYTE zero means do not display multibyte chars, > 0 means do
21928 display them, and < 0 means obey the current buffer's value of
21929 enable_multibyte_characters.
21931 Value is the number of columns displayed. */
21934 display_string (const char *string
, Lisp_Object lisp_string
, Lisp_Object face_string
,
21935 ptrdiff_t face_string_pos
, ptrdiff_t start
, struct it
*it
,
21936 int field_width
, int precision
, int max_x
, int multibyte
)
21938 int hpos_at_start
= it
->hpos
;
21939 int saved_face_id
= it
->face_id
;
21940 struct glyph_row
*row
= it
->glyph_row
;
21941 ptrdiff_t it_charpos
;
21943 /* Initialize the iterator IT for iteration over STRING beginning
21944 with index START. */
21945 reseat_to_string (it
, NILP (lisp_string
) ? string
: NULL
, lisp_string
, start
,
21946 precision
, field_width
, multibyte
);
21947 if (string
&& STRINGP (lisp_string
))
21948 /* LISP_STRING is the one returned by decode_mode_spec. We should
21949 ignore its text properties. */
21950 it
->stop_charpos
= it
->end_charpos
;
21952 /* If displaying STRING, set up the face of the iterator from
21953 FACE_STRING, if that's given. */
21954 if (STRINGP (face_string
))
21960 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
21961 0, it
->region_beg_charpos
,
21962 it
->region_end_charpos
,
21963 &endptr
, it
->base_face_id
, 0);
21964 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
21965 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
21968 /* Set max_x to the maximum allowed X position. Don't let it go
21969 beyond the right edge of the window. */
21971 max_x
= it
->last_visible_x
;
21973 max_x
= min (max_x
, it
->last_visible_x
);
21975 /* Skip over display elements that are not visible. because IT->w is
21977 if (it
->current_x
< it
->first_visible_x
)
21978 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
21979 MOVE_TO_POS
| MOVE_TO_X
);
21981 row
->ascent
= it
->max_ascent
;
21982 row
->height
= it
->max_ascent
+ it
->max_descent
;
21983 row
->phys_ascent
= it
->max_phys_ascent
;
21984 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
21985 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
21987 if (STRINGP (it
->string
))
21988 it_charpos
= IT_STRING_CHARPOS (*it
);
21990 it_charpos
= IT_CHARPOS (*it
);
21992 /* This condition is for the case that we are called with current_x
21993 past last_visible_x. */
21994 while (it
->current_x
< max_x
)
21996 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
21998 /* Get the next display element. */
21999 if (!get_next_display_element (it
))
22002 /* Produce glyphs. */
22003 x_before
= it
->current_x
;
22004 n_glyphs_before
= row
->used
[TEXT_AREA
];
22005 PRODUCE_GLYPHS (it
);
22007 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
22010 while (i
< nglyphs
)
22012 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
22014 if (it
->line_wrap
!= TRUNCATE
22015 && x
+ glyph
->pixel_width
> max_x
)
22017 /* End of continued line or max_x reached. */
22018 if (CHAR_GLYPH_PADDING_P (*glyph
))
22020 /* A wide character is unbreakable. */
22021 if (row
->reversed_p
)
22022 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
22023 - n_glyphs_before
);
22024 row
->used
[TEXT_AREA
] = n_glyphs_before
;
22025 it
->current_x
= x_before
;
22029 if (row
->reversed_p
)
22030 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
22031 - (n_glyphs_before
+ i
));
22032 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
22037 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
22039 /* Glyph is at least partially visible. */
22041 if (x
< it
->first_visible_x
)
22042 row
->x
= x
- it
->first_visible_x
;
22046 /* Glyph is off the left margin of the display area.
22047 Should not happen. */
22051 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
22052 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
22053 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
22054 row
->phys_height
= max (row
->phys_height
,
22055 it
->max_phys_ascent
+ it
->max_phys_descent
);
22056 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
22057 it
->max_extra_line_spacing
);
22058 x
+= glyph
->pixel_width
;
22062 /* Stop if max_x reached. */
22066 /* Stop at line ends. */
22067 if (ITERATOR_AT_END_OF_LINE_P (it
))
22069 it
->continuation_lines_width
= 0;
22073 set_iterator_to_next (it
, 1);
22074 if (STRINGP (it
->string
))
22075 it_charpos
= IT_STRING_CHARPOS (*it
);
22077 it_charpos
= IT_CHARPOS (*it
);
22079 /* Stop if truncating at the right edge. */
22080 if (it
->line_wrap
== TRUNCATE
22081 && it
->current_x
>= it
->last_visible_x
)
22083 /* Add truncation mark, but don't do it if the line is
22084 truncated at a padding space. */
22085 if (it_charpos
< it
->string_nchars
)
22087 if (!FRAME_WINDOW_P (it
->f
))
22091 if (it
->current_x
> it
->last_visible_x
)
22093 if (!row
->reversed_p
)
22095 for (ii
= row
->used
[TEXT_AREA
] - 1; ii
> 0; --ii
)
22096 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
22101 for (ii
= 0; ii
< row
->used
[TEXT_AREA
]; ii
++)
22102 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
22104 unproduce_glyphs (it
, ii
+ 1);
22105 ii
= row
->used
[TEXT_AREA
] - (ii
+ 1);
22107 for (n
= row
->used
[TEXT_AREA
]; ii
< n
; ++ii
)
22109 row
->used
[TEXT_AREA
] = ii
;
22110 produce_special_glyphs (it
, IT_TRUNCATION
);
22113 produce_special_glyphs (it
, IT_TRUNCATION
);
22115 row
->truncated_on_right_p
= 1;
22121 /* Maybe insert a truncation at the left. */
22122 if (it
->first_visible_x
22125 if (!FRAME_WINDOW_P (it
->f
)
22126 || (row
->reversed_p
22127 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
22128 : WINDOW_LEFT_FRINGE_WIDTH (it
->w
)) == 0)
22129 insert_left_trunc_glyphs (it
);
22130 row
->truncated_on_left_p
= 1;
22133 it
->face_id
= saved_face_id
;
22135 /* Value is number of columns displayed. */
22136 return it
->hpos
- hpos_at_start
;
22141 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
22142 appears as an element of LIST or as the car of an element of LIST.
22143 If PROPVAL is a list, compare each element against LIST in that
22144 way, and return 1/2 if any element of PROPVAL is found in LIST.
22145 Otherwise return 0. This function cannot quit.
22146 The return value is 2 if the text is invisible but with an ellipsis
22147 and 1 if it's invisible and without an ellipsis. */
22150 invisible_p (register Lisp_Object propval
, Lisp_Object list
)
22152 register Lisp_Object tail
, proptail
;
22154 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
22156 register Lisp_Object tem
;
22158 if (EQ (propval
, tem
))
22160 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
22161 return NILP (XCDR (tem
)) ? 1 : 2;
22164 if (CONSP (propval
))
22166 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
22168 Lisp_Object propelt
;
22169 propelt
= XCAR (proptail
);
22170 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
22172 register Lisp_Object tem
;
22174 if (EQ (propelt
, tem
))
22176 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
22177 return NILP (XCDR (tem
)) ? 1 : 2;
22185 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
22186 doc
: /* Non-nil if the property makes the text invisible.
22187 POS-OR-PROP can be a marker or number, in which case it is taken to be
22188 a position in the current buffer and the value of the `invisible' property
22189 is checked; or it can be some other value, which is then presumed to be the
22190 value of the `invisible' property of the text of interest.
22191 The non-nil value returned can be t for truly invisible text or something
22192 else if the text is replaced by an ellipsis. */)
22193 (Lisp_Object pos_or_prop
)
22196 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
22197 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
22199 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
22200 return (invis
== 0 ? Qnil
22202 : make_number (invis
));
22205 /* Calculate a width or height in pixels from a specification using
22206 the following elements:
22209 NUM - a (fractional) multiple of the default font width/height
22210 (NUM) - specifies exactly NUM pixels
22211 UNIT - a fixed number of pixels, see below.
22212 ELEMENT - size of a display element in pixels, see below.
22213 (NUM . SPEC) - equals NUM * SPEC
22214 (+ SPEC SPEC ...) - add pixel values
22215 (- SPEC SPEC ...) - subtract pixel values
22216 (- SPEC) - negate pixel value
22219 INT or FLOAT - a number constant
22220 SYMBOL - use symbol's (buffer local) variable binding.
22223 in - pixels per inch *)
22224 mm - pixels per 1/1000 meter *)
22225 cm - pixels per 1/100 meter *)
22226 width - width of current font in pixels.
22227 height - height of current font in pixels.
22229 *) using the ratio(s) defined in display-pixels-per-inch.
22233 left-fringe - left fringe width in pixels
22234 right-fringe - right fringe width in pixels
22236 left-margin - left margin width in pixels
22237 right-margin - right margin width in pixels
22239 scroll-bar - scroll-bar area width in pixels
22243 Pixels corresponding to 5 inches:
22246 Total width of non-text areas on left side of window (if scroll-bar is on left):
22247 '(space :width (+ left-fringe left-margin scroll-bar))
22249 Align to first text column (in header line):
22250 '(space :align-to 0)
22252 Align to middle of text area minus half the width of variable `my-image'
22253 containing a loaded image:
22254 '(space :align-to (0.5 . (- text my-image)))
22256 Width of left margin minus width of 1 character in the default font:
22257 '(space :width (- left-margin 1))
22259 Width of left margin minus width of 2 characters in the current font:
22260 '(space :width (- left-margin (2 . width)))
22262 Center 1 character over left-margin (in header line):
22263 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
22265 Different ways to express width of left fringe plus left margin minus one pixel:
22266 '(space :width (- (+ left-fringe left-margin) (1)))
22267 '(space :width (+ left-fringe left-margin (- (1))))
22268 '(space :width (+ left-fringe left-margin (-1)))
22272 #define NUMVAL(X) \
22273 ((INTEGERP (X) || FLOATP (X)) \
22278 calc_pixel_width_or_height (double *res
, struct it
*it
, Lisp_Object prop
,
22279 struct font
*font
, int width_p
, int *align_to
)
22283 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
22284 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
22287 return OK_PIXELS (0);
22289 eassert (FRAME_LIVE_P (it
->f
));
22291 if (SYMBOLP (prop
))
22293 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
22295 char *unit
= SSDATA (SYMBOL_NAME (prop
));
22297 if (unit
[0] == 'i' && unit
[1] == 'n')
22299 else if (unit
[0] == 'm' && unit
[1] == 'm')
22301 else if (unit
[0] == 'c' && unit
[1] == 'm')
22308 #ifdef HAVE_WINDOW_SYSTEM
22309 if (FRAME_WINDOW_P (it
->f
)
22311 ? FRAME_X_DISPLAY_INFO (it
->f
)->resx
22312 : FRAME_X_DISPLAY_INFO (it
->f
)->resy
),
22314 return OK_PIXELS (ppi
/ pixels
);
22317 if ((ppi
= NUMVAL (Vdisplay_pixels_per_inch
), ppi
> 0)
22318 || (CONSP (Vdisplay_pixels_per_inch
)
22320 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch
))
22321 : NUMVAL (XCDR (Vdisplay_pixels_per_inch
))),
22323 return OK_PIXELS (ppi
/ pixels
);
22329 #ifdef HAVE_WINDOW_SYSTEM
22330 if (EQ (prop
, Qheight
))
22331 return OK_PIXELS (font
? FONT_HEIGHT (font
) : FRAME_LINE_HEIGHT (it
->f
));
22332 if (EQ (prop
, Qwidth
))
22333 return OK_PIXELS (font
? FONT_WIDTH (font
) : FRAME_COLUMN_WIDTH (it
->f
));
22335 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
22336 return OK_PIXELS (1);
22339 if (EQ (prop
, Qtext
))
22340 return OK_PIXELS (width_p
22341 ? window_box_width (it
->w
, TEXT_AREA
)
22342 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
22344 if (align_to
&& *align_to
< 0)
22347 if (EQ (prop
, Qleft
))
22348 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
22349 if (EQ (prop
, Qright
))
22350 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
22351 if (EQ (prop
, Qcenter
))
22352 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
22353 + window_box_width (it
->w
, TEXT_AREA
) / 2);
22354 if (EQ (prop
, Qleft_fringe
))
22355 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22356 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
22357 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
22358 if (EQ (prop
, Qright_fringe
))
22359 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22360 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
22361 : window_box_right_offset (it
->w
, TEXT_AREA
));
22362 if (EQ (prop
, Qleft_margin
))
22363 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
22364 if (EQ (prop
, Qright_margin
))
22365 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
22366 if (EQ (prop
, Qscroll_bar
))
22367 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
22369 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
22370 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
22371 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
22376 if (EQ (prop
, Qleft_fringe
))
22377 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
22378 if (EQ (prop
, Qright_fringe
))
22379 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
22380 if (EQ (prop
, Qleft_margin
))
22381 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
22382 if (EQ (prop
, Qright_margin
))
22383 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
22384 if (EQ (prop
, Qscroll_bar
))
22385 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
22388 prop
= buffer_local_value_1 (prop
, it
->w
->buffer
);
22389 if (EQ (prop
, Qunbound
))
22393 if (INTEGERP (prop
) || FLOATP (prop
))
22395 int base_unit
= (width_p
22396 ? FRAME_COLUMN_WIDTH (it
->f
)
22397 : FRAME_LINE_HEIGHT (it
->f
));
22398 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
22403 Lisp_Object car
= XCAR (prop
);
22404 Lisp_Object cdr
= XCDR (prop
);
22408 #ifdef HAVE_WINDOW_SYSTEM
22409 if (FRAME_WINDOW_P (it
->f
)
22410 && valid_image_p (prop
))
22412 ptrdiff_t id
= lookup_image (it
->f
, prop
);
22413 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
22415 return OK_PIXELS (width_p
? img
->width
: img
->height
);
22418 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
22424 while (CONSP (cdr
))
22426 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
22427 font
, width_p
, align_to
))
22430 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
22435 if (EQ (car
, Qminus
))
22437 return OK_PIXELS (pixels
);
22440 car
= buffer_local_value_1 (car
, it
->w
->buffer
);
22441 if (EQ (car
, Qunbound
))
22445 if (INTEGERP (car
) || FLOATP (car
))
22448 pixels
= XFLOATINT (car
);
22450 return OK_PIXELS (pixels
);
22451 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
22452 font
, width_p
, align_to
))
22453 return OK_PIXELS (pixels
* fact
);
22464 /***********************************************************************
22466 ***********************************************************************/
22468 #ifdef HAVE_WINDOW_SYSTEM
22473 dump_glyph_string (struct glyph_string
*s
)
22475 fprintf (stderr
, "glyph string\n");
22476 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
22477 s
->x
, s
->y
, s
->width
, s
->height
);
22478 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
22479 fprintf (stderr
, " hl = %d\n", s
->hl
);
22480 fprintf (stderr
, " left overhang = %d, right = %d\n",
22481 s
->left_overhang
, s
->right_overhang
);
22482 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
22483 fprintf (stderr
, " extends to end of line = %d\n",
22484 s
->extends_to_end_of_line_p
);
22485 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
22486 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
22489 #endif /* GLYPH_DEBUG */
22491 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
22492 of XChar2b structures for S; it can't be allocated in
22493 init_glyph_string because it must be allocated via `alloca'. W
22494 is the window on which S is drawn. ROW and AREA are the glyph row
22495 and area within the row from which S is constructed. START is the
22496 index of the first glyph structure covered by S. HL is a
22497 face-override for drawing S. */
22500 #define OPTIONAL_HDC(hdc) HDC hdc,
22501 #define DECLARE_HDC(hdc) HDC hdc;
22502 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
22503 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
22506 #ifndef OPTIONAL_HDC
22507 #define OPTIONAL_HDC(hdc)
22508 #define DECLARE_HDC(hdc)
22509 #define ALLOCATE_HDC(hdc, f)
22510 #define RELEASE_HDC(hdc, f)
22514 init_glyph_string (struct glyph_string
*s
,
22516 XChar2b
*char2b
, struct window
*w
, struct glyph_row
*row
,
22517 enum glyph_row_area area
, int start
, enum draw_glyphs_face hl
)
22519 memset (s
, 0, sizeof *s
);
22521 s
->f
= XFRAME (w
->frame
);
22525 s
->display
= FRAME_X_DISPLAY (s
->f
);
22526 s
->window
= FRAME_X_WINDOW (s
->f
);
22527 s
->char2b
= char2b
;
22531 s
->first_glyph
= row
->glyphs
[area
] + start
;
22532 s
->height
= row
->height
;
22533 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
22534 s
->ybase
= s
->y
+ row
->ascent
;
22538 /* Append the list of glyph strings with head H and tail T to the list
22539 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
22542 append_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
22543 struct glyph_string
*h
, struct glyph_string
*t
)
22557 /* Prepend the list of glyph strings with head H and tail T to the
22558 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
22562 prepend_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
22563 struct glyph_string
*h
, struct glyph_string
*t
)
22577 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
22578 Set *HEAD and *TAIL to the resulting list. */
22581 append_glyph_string (struct glyph_string
**head
, struct glyph_string
**tail
,
22582 struct glyph_string
*s
)
22584 s
->next
= s
->prev
= NULL
;
22585 append_glyph_string_lists (head
, tail
, s
, s
);
22589 /* Get face and two-byte form of character C in face FACE_ID on frame F.
22590 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
22591 make sure that X resources for the face returned are allocated.
22592 Value is a pointer to a realized face that is ready for display if
22593 DISPLAY_P is non-zero. */
22595 static struct face
*
22596 get_char_face_and_encoding (struct frame
*f
, int c
, int face_id
,
22597 XChar2b
*char2b
, int display_p
)
22599 struct face
*face
= FACE_FROM_ID (f
, face_id
);
22603 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
22605 if (code
!= FONT_INVALID_CODE
)
22606 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22608 STORE_XCHAR2B (char2b
, 0, 0);
22611 /* Make sure X resources of the face are allocated. */
22612 #ifdef HAVE_X_WINDOWS
22616 eassert (face
!= NULL
);
22617 PREPARE_FACE_FOR_DISPLAY (f
, face
);
22624 /* Get face and two-byte form of character glyph GLYPH on frame F.
22625 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
22626 a pointer to a realized face that is ready for display. */
22628 static struct face
*
22629 get_glyph_face_and_encoding (struct frame
*f
, struct glyph
*glyph
,
22630 XChar2b
*char2b
, int *two_byte_p
)
22634 eassert (glyph
->type
== CHAR_GLYPH
);
22635 face
= FACE_FROM_ID (f
, glyph
->face_id
);
22644 if (CHAR_BYTE8_P (glyph
->u
.ch
))
22645 code
= CHAR_TO_BYTE8 (glyph
->u
.ch
);
22647 code
= face
->font
->driver
->encode_char (face
->font
, glyph
->u
.ch
);
22649 if (code
!= FONT_INVALID_CODE
)
22650 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22652 STORE_XCHAR2B (char2b
, 0, 0);
22655 /* Make sure X resources of the face are allocated. */
22656 eassert (face
!= NULL
);
22657 PREPARE_FACE_FOR_DISPLAY (f
, face
);
22662 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
22663 Return 1 if FONT has a glyph for C, otherwise return 0. */
22666 get_char_glyph_code (int c
, struct font
*font
, XChar2b
*char2b
)
22670 if (CHAR_BYTE8_P (c
))
22671 code
= CHAR_TO_BYTE8 (c
);
22673 code
= font
->driver
->encode_char (font
, c
);
22675 if (code
== FONT_INVALID_CODE
)
22677 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
22682 /* Fill glyph string S with composition components specified by S->cmp.
22684 BASE_FACE is the base face of the composition.
22685 S->cmp_from is the index of the first component for S.
22687 OVERLAPS non-zero means S should draw the foreground only, and use
22688 its physical height for clipping. See also draw_glyphs.
22690 Value is the index of a component not in S. */
22693 fill_composite_glyph_string (struct glyph_string
*s
, struct face
*base_face
,
22697 /* For all glyphs of this composition, starting at the offset
22698 S->cmp_from, until we reach the end of the definition or encounter a
22699 glyph that requires the different face, add it to S. */
22704 s
->for_overlaps
= overlaps
;
22707 for (i
= s
->cmp_from
; i
< s
->cmp
->glyph_len
; i
++)
22709 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
22711 /* TAB in a composition means display glyphs with padding space
22712 on the left or right. */
22715 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
->ascii_face
, c
,
22718 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
22725 s
->font
= s
->face
->font
;
22727 else if (s
->face
!= face
)
22735 if (s
->face
== NULL
)
22737 s
->face
= base_face
->ascii_face
;
22738 s
->font
= s
->face
->font
;
22741 /* All glyph strings for the same composition has the same width,
22742 i.e. the width set for the first component of the composition. */
22743 s
->width
= s
->first_glyph
->pixel_width
;
22745 /* If the specified font could not be loaded, use the frame's
22746 default font, but record the fact that we couldn't load it in
22747 the glyph string so that we can draw rectangles for the
22748 characters of the glyph string. */
22749 if (s
->font
== NULL
)
22751 s
->font_not_found_p
= 1;
22752 s
->font
= FRAME_FONT (s
->f
);
22755 /* Adjust base line for subscript/superscript text. */
22756 s
->ybase
+= s
->first_glyph
->voffset
;
22758 /* This glyph string must always be drawn with 16-bit functions. */
22765 fill_gstring_glyph_string (struct glyph_string
*s
, int face_id
,
22766 int start
, int end
, int overlaps
)
22768 struct glyph
*glyph
, *last
;
22769 Lisp_Object lgstring
;
22772 s
->for_overlaps
= overlaps
;
22773 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22774 last
= s
->row
->glyphs
[s
->area
] + end
;
22775 s
->cmp_id
= glyph
->u
.cmp
.id
;
22776 s
->cmp_from
= glyph
->slice
.cmp
.from
;
22777 s
->cmp_to
= glyph
->slice
.cmp
.to
+ 1;
22778 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22779 lgstring
= composition_gstring_from_id (s
->cmp_id
);
22780 s
->font
= XFONT_OBJECT (LGSTRING_FONT (lgstring
));
22782 while (glyph
< last
22783 && glyph
->u
.cmp
.automatic
22784 && glyph
->u
.cmp
.id
== s
->cmp_id
22785 && s
->cmp_to
== glyph
->slice
.cmp
.from
)
22786 s
->cmp_to
= (glyph
++)->slice
.cmp
.to
+ 1;
22788 for (i
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
22790 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
22791 unsigned code
= LGLYPH_CODE (lglyph
);
22793 STORE_XCHAR2B ((s
->char2b
+ i
), code
>> 8, code
& 0xFF);
22795 s
->width
= composition_gstring_width (lgstring
, s
->cmp_from
, s
->cmp_to
, NULL
);
22796 return glyph
- s
->row
->glyphs
[s
->area
];
22800 /* Fill glyph string S from a sequence glyphs for glyphless characters.
22801 See the comment of fill_glyph_string for arguments.
22802 Value is the index of the first glyph not in S. */
22806 fill_glyphless_glyph_string (struct glyph_string
*s
, int face_id
,
22807 int start
, int end
, int overlaps
)
22809 struct glyph
*glyph
, *last
;
22812 eassert (s
->first_glyph
->type
== GLYPHLESS_GLYPH
);
22813 s
->for_overlaps
= overlaps
;
22814 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22815 last
= s
->row
->glyphs
[s
->area
] + end
;
22816 voffset
= glyph
->voffset
;
22817 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22818 s
->font
= s
->face
->font
? s
->face
->font
: FRAME_FONT (s
->f
);
22820 s
->width
= glyph
->pixel_width
;
22822 while (glyph
< last
22823 && glyph
->type
== GLYPHLESS_GLYPH
22824 && glyph
->voffset
== voffset
22825 && glyph
->face_id
== face_id
)
22828 s
->width
+= glyph
->pixel_width
;
22831 s
->ybase
+= voffset
;
22832 return glyph
- s
->row
->glyphs
[s
->area
];
22836 /* Fill glyph string S from a sequence of character glyphs.
22838 FACE_ID is the face id of the string. START is the index of the
22839 first glyph to consider, END is the index of the last + 1.
22840 OVERLAPS non-zero means S should draw the foreground only, and use
22841 its physical height for clipping. See also draw_glyphs.
22843 Value is the index of the first glyph not in S. */
22846 fill_glyph_string (struct glyph_string
*s
, int face_id
,
22847 int start
, int end
, int overlaps
)
22849 struct glyph
*glyph
, *last
;
22851 int glyph_not_available_p
;
22853 eassert (s
->f
== XFRAME (s
->w
->frame
));
22854 eassert (s
->nchars
== 0);
22855 eassert (start
>= 0 && end
> start
);
22857 s
->for_overlaps
= overlaps
;
22858 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22859 last
= s
->row
->glyphs
[s
->area
] + end
;
22860 voffset
= glyph
->voffset
;
22861 s
->padding_p
= glyph
->padding_p
;
22862 glyph_not_available_p
= glyph
->glyph_not_available_p
;
22864 while (glyph
< last
22865 && glyph
->type
== CHAR_GLYPH
22866 && glyph
->voffset
== voffset
22867 /* Same face id implies same font, nowadays. */
22868 && glyph
->face_id
== face_id
22869 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
22873 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
22874 s
->char2b
+ s
->nchars
,
22876 s
->two_byte_p
= two_byte_p
;
22878 eassert (s
->nchars
<= end
- start
);
22879 s
->width
+= glyph
->pixel_width
;
22880 if (glyph
++->padding_p
!= s
->padding_p
)
22884 s
->font
= s
->face
->font
;
22886 /* If the specified font could not be loaded, use the frame's font,
22887 but record the fact that we couldn't load it in
22888 S->font_not_found_p so that we can draw rectangles for the
22889 characters of the glyph string. */
22890 if (s
->font
== NULL
|| glyph_not_available_p
)
22892 s
->font_not_found_p
= 1;
22893 s
->font
= FRAME_FONT (s
->f
);
22896 /* Adjust base line for subscript/superscript text. */
22897 s
->ybase
+= voffset
;
22899 eassert (s
->face
&& s
->face
->gc
);
22900 return glyph
- s
->row
->glyphs
[s
->area
];
22904 /* Fill glyph string S from image glyph S->first_glyph. */
22907 fill_image_glyph_string (struct glyph_string
*s
)
22909 eassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
22910 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
22912 s
->slice
= s
->first_glyph
->slice
.img
;
22913 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
22914 s
->font
= s
->face
->font
;
22915 s
->width
= s
->first_glyph
->pixel_width
;
22917 /* Adjust base line for subscript/superscript text. */
22918 s
->ybase
+= s
->first_glyph
->voffset
;
22922 /* Fill glyph string S from a sequence of stretch glyphs.
22924 START is the index of the first glyph to consider,
22925 END is the index of the last + 1.
22927 Value is the index of the first glyph not in S. */
22930 fill_stretch_glyph_string (struct glyph_string
*s
, int start
, int end
)
22932 struct glyph
*glyph
, *last
;
22933 int voffset
, face_id
;
22935 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
22937 glyph
= s
->row
->glyphs
[s
->area
] + start
;
22938 last
= s
->row
->glyphs
[s
->area
] + end
;
22939 face_id
= glyph
->face_id
;
22940 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
22941 s
->font
= s
->face
->font
;
22942 s
->width
= glyph
->pixel_width
;
22944 voffset
= glyph
->voffset
;
22948 && glyph
->type
== STRETCH_GLYPH
22949 && glyph
->voffset
== voffset
22950 && glyph
->face_id
== face_id
);
22952 s
->width
+= glyph
->pixel_width
;
22954 /* Adjust base line for subscript/superscript text. */
22955 s
->ybase
+= voffset
;
22957 /* The case that face->gc == 0 is handled when drawing the glyph
22958 string by calling PREPARE_FACE_FOR_DISPLAY. */
22960 return glyph
- s
->row
->glyphs
[s
->area
];
22963 static struct font_metrics
*
22964 get_per_char_metric (struct font
*font
, XChar2b
*char2b
)
22966 static struct font_metrics metrics
;
22967 unsigned code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
22969 if (! font
|| code
== FONT_INVALID_CODE
)
22971 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
22976 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
22977 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
22978 assumed to be zero. */
22981 x_get_glyph_overhangs (struct glyph
*glyph
, struct frame
*f
, int *left
, int *right
)
22983 *left
= *right
= 0;
22985 if (glyph
->type
== CHAR_GLYPH
)
22989 struct font_metrics
*pcm
;
22991 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
22992 if (face
->font
&& (pcm
= get_per_char_metric (face
->font
, &char2b
)))
22994 if (pcm
->rbearing
> pcm
->width
)
22995 *right
= pcm
->rbearing
- pcm
->width
;
22996 if (pcm
->lbearing
< 0)
22997 *left
= -pcm
->lbearing
;
23000 else if (glyph
->type
== COMPOSITE_GLYPH
)
23002 if (! glyph
->u
.cmp
.automatic
)
23004 struct composition
*cmp
= composition_table
[glyph
->u
.cmp
.id
];
23006 if (cmp
->rbearing
> cmp
->pixel_width
)
23007 *right
= cmp
->rbearing
- cmp
->pixel_width
;
23008 if (cmp
->lbearing
< 0)
23009 *left
= - cmp
->lbearing
;
23013 Lisp_Object gstring
= composition_gstring_from_id (glyph
->u
.cmp
.id
);
23014 struct font_metrics metrics
;
23016 composition_gstring_width (gstring
, glyph
->slice
.cmp
.from
,
23017 glyph
->slice
.cmp
.to
+ 1, &metrics
);
23018 if (metrics
.rbearing
> metrics
.width
)
23019 *right
= metrics
.rbearing
- metrics
.width
;
23020 if (metrics
.lbearing
< 0)
23021 *left
= - metrics
.lbearing
;
23027 /* Return the index of the first glyph preceding glyph string S that
23028 is overwritten by S because of S's left overhang. Value is -1
23029 if no glyphs are overwritten. */
23032 left_overwritten (struct glyph_string
*s
)
23036 if (s
->left_overhang
)
23039 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23040 int first
= s
->first_glyph
- glyphs
;
23042 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
23043 x
-= glyphs
[i
].pixel_width
;
23054 /* Return the index of the first glyph preceding glyph string S that
23055 is overwriting S because of its right overhang. Value is -1 if no
23056 glyph in front of S overwrites S. */
23059 left_overwriting (struct glyph_string
*s
)
23062 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23063 int first
= s
->first_glyph
- glyphs
;
23067 for (i
= first
- 1; i
>= 0; --i
)
23070 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
23073 x
-= glyphs
[i
].pixel_width
;
23080 /* Return the index of the last glyph following glyph string S that is
23081 overwritten by S because of S's right overhang. Value is -1 if
23082 no such glyph is found. */
23085 right_overwritten (struct glyph_string
*s
)
23089 if (s
->right_overhang
)
23092 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23093 int first
= (s
->first_glyph
- glyphs
23094 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
23095 int end
= s
->row
->used
[s
->area
];
23097 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
23098 x
+= glyphs
[i
].pixel_width
;
23107 /* Return the index of the last glyph following glyph string S that
23108 overwrites S because of its left overhang. Value is negative
23109 if no such glyph is found. */
23112 right_overwriting (struct glyph_string
*s
)
23115 int end
= s
->row
->used
[s
->area
];
23116 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
23117 int first
= (s
->first_glyph
- glyphs
23118 + (s
->first_glyph
->type
== COMPOSITE_GLYPH
? 1 : s
->nchars
));
23122 for (i
= first
; i
< end
; ++i
)
23125 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
23128 x
+= glyphs
[i
].pixel_width
;
23135 /* Set background width of glyph string S. START is the index of the
23136 first glyph following S. LAST_X is the right-most x-position + 1
23137 in the drawing area. */
23140 set_glyph_string_background_width (struct glyph_string
*s
, int start
, int last_x
)
23142 /* If the face of this glyph string has to be drawn to the end of
23143 the drawing area, set S->extends_to_end_of_line_p. */
23145 if (start
== s
->row
->used
[s
->area
]
23146 && s
->area
== TEXT_AREA
23147 && ((s
->row
->fill_line_p
23148 && (s
->hl
== DRAW_NORMAL_TEXT
23149 || s
->hl
== DRAW_IMAGE_RAISED
23150 || s
->hl
== DRAW_IMAGE_SUNKEN
))
23151 || s
->hl
== DRAW_MOUSE_FACE
))
23152 s
->extends_to_end_of_line_p
= 1;
23154 /* If S extends its face to the end of the line, set its
23155 background_width to the distance to the right edge of the drawing
23157 if (s
->extends_to_end_of_line_p
)
23158 s
->background_width
= last_x
- s
->x
+ 1;
23160 s
->background_width
= s
->width
;
23164 /* Compute overhangs and x-positions for glyph string S and its
23165 predecessors, or successors. X is the starting x-position for S.
23166 BACKWARD_P non-zero means process predecessors. */
23169 compute_overhangs_and_x (struct glyph_string
*s
, int x
, int backward_p
)
23175 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
23176 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
23186 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
23187 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
23197 /* The following macros are only called from draw_glyphs below.
23198 They reference the following parameters of that function directly:
23199 `w', `row', `area', and `overlap_p'
23200 as well as the following local variables:
23201 `s', `f', and `hdc' (in W32) */
23204 /* On W32, silently add local `hdc' variable to argument list of
23205 init_glyph_string. */
23206 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
23207 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
23209 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
23210 init_glyph_string (s, char2b, w, row, area, start, hl)
23213 /* Add a glyph string for a stretch glyph to the list of strings
23214 between HEAD and TAIL. START is the index of the stretch glyph in
23215 row area AREA of glyph row ROW. END is the index of the last glyph
23216 in that glyph row area. X is the current output position assigned
23217 to the new glyph string constructed. HL overrides that face of the
23218 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
23219 is the right-most x-position of the drawing area. */
23221 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
23222 and below -- keep them on one line. */
23223 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23226 s = alloca (sizeof *s); \
23227 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23228 START = fill_stretch_glyph_string (s, START, END); \
23229 append_glyph_string (&HEAD, &TAIL, s); \
23235 /* Add a glyph string for an image glyph to the list of strings
23236 between HEAD and TAIL. START is the index of the image glyph in
23237 row area AREA of glyph row ROW. END is the index of the last glyph
23238 in that glyph row area. X is the current output position assigned
23239 to the new glyph string constructed. HL overrides that face of the
23240 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
23241 is the right-most x-position of the drawing area. */
23243 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23246 s = alloca (sizeof *s); \
23247 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23248 fill_image_glyph_string (s); \
23249 append_glyph_string (&HEAD, &TAIL, s); \
23256 /* Add a glyph string for a sequence of character glyphs to the list
23257 of strings between HEAD and TAIL. START is the index of the first
23258 glyph in row area AREA of glyph row ROW that is part of the new
23259 glyph string. END is the index of the last glyph in that glyph row
23260 area. X is the current output position assigned to the new glyph
23261 string constructed. HL overrides that face of the glyph; e.g. it
23262 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
23263 right-most x-position of the drawing area. */
23265 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
23271 face_id = (row)->glyphs[area][START].face_id; \
23273 s = alloca (sizeof *s); \
23274 char2b = alloca ((END - START) * sizeof *char2b); \
23275 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23276 append_glyph_string (&HEAD, &TAIL, s); \
23278 START = fill_glyph_string (s, face_id, START, END, overlaps); \
23283 /* Add a glyph string for a composite sequence to the list of strings
23284 between HEAD and TAIL. START is the index of the first glyph in
23285 row area AREA of glyph row ROW that is part of the new glyph
23286 string. END is the index of the last glyph in that glyph row area.
23287 X is the current output position assigned to the new glyph string
23288 constructed. HL overrides that face of the glyph; e.g. it is
23289 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
23290 x-position of the drawing area. */
23292 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23294 int face_id = (row)->glyphs[area][START].face_id; \
23295 struct face *base_face = FACE_FROM_ID (f, face_id); \
23296 ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id; \
23297 struct composition *cmp = composition_table[cmp_id]; \
23299 struct glyph_string *first_s = NULL; \
23302 char2b = alloca (cmp->glyph_len * sizeof *char2b); \
23304 /* Make glyph_strings for each glyph sequence that is drawable by \
23305 the same face, and append them to HEAD/TAIL. */ \
23306 for (n = 0; n < cmp->glyph_len;) \
23308 s = alloca (sizeof *s); \
23309 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23310 append_glyph_string (&(HEAD), &(TAIL), s); \
23316 n = fill_composite_glyph_string (s, base_face, overlaps); \
23324 /* Add a glyph string for a glyph-string sequence to the list of strings
23325 between HEAD and TAIL. */
23327 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23331 Lisp_Object gstring; \
23333 face_id = (row)->glyphs[area][START].face_id; \
23334 gstring = (composition_gstring_from_id \
23335 ((row)->glyphs[area][START].u.cmp.id)); \
23336 s = alloca (sizeof *s); \
23337 char2b = alloca (LGSTRING_GLYPH_LEN (gstring) * sizeof *char2b); \
23338 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
23339 append_glyph_string (&(HEAD), &(TAIL), s); \
23341 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
23345 /* Add a glyph string for a sequence of glyphless character's glyphs
23346 to the list of strings between HEAD and TAIL. The meanings of
23347 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
23349 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
23354 face_id = (row)->glyphs[area][START].face_id; \
23356 s = alloca (sizeof *s); \
23357 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
23358 append_glyph_string (&HEAD, &TAIL, s); \
23360 START = fill_glyphless_glyph_string (s, face_id, START, END, \
23366 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
23367 of AREA of glyph row ROW on window W between indices START and END.
23368 HL overrides the face for drawing glyph strings, e.g. it is
23369 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
23370 x-positions of the drawing area.
23372 This is an ugly monster macro construct because we must use alloca
23373 to allocate glyph strings (because draw_glyphs can be called
23374 asynchronously). */
23376 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
23379 HEAD = TAIL = NULL; \
23380 while (START < END) \
23382 struct glyph *first_glyph = (row)->glyphs[area] + START; \
23383 switch (first_glyph->type) \
23386 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
23390 case COMPOSITE_GLYPH: \
23391 if (first_glyph->u.cmp.automatic) \
23392 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
23395 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
23399 case STRETCH_GLYPH: \
23400 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
23404 case IMAGE_GLYPH: \
23405 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
23409 case GLYPHLESS_GLYPH: \
23410 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
23420 set_glyph_string_background_width (s, START, LAST_X); \
23427 /* Draw glyphs between START and END in AREA of ROW on window W,
23428 starting at x-position X. X is relative to AREA in W. HL is a
23429 face-override with the following meaning:
23431 DRAW_NORMAL_TEXT draw normally
23432 DRAW_CURSOR draw in cursor face
23433 DRAW_MOUSE_FACE draw in mouse face.
23434 DRAW_INVERSE_VIDEO draw in mode line face
23435 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
23436 DRAW_IMAGE_RAISED draw an image with a raised relief around it
23438 If OVERLAPS is non-zero, draw only the foreground of characters and
23439 clip to the physical height of ROW. Non-zero value also defines
23440 the overlapping part to be drawn:
23442 OVERLAPS_PRED overlap with preceding rows
23443 OVERLAPS_SUCC overlap with succeeding rows
23444 OVERLAPS_BOTH overlap with both preceding/succeeding rows
23445 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
23447 Value is the x-position reached, relative to AREA of W. */
23450 draw_glyphs (struct window
*w
, int x
, struct glyph_row
*row
,
23451 enum glyph_row_area area
, ptrdiff_t start
, ptrdiff_t end
,
23452 enum draw_glyphs_face hl
, int overlaps
)
23454 struct glyph_string
*head
, *tail
;
23455 struct glyph_string
*s
;
23456 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
23457 int i
, j
, x_reached
, last_x
, area_left
= 0;
23458 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
23461 ALLOCATE_HDC (hdc
, f
);
23463 /* Let's rather be paranoid than getting a SEGV. */
23464 end
= min (end
, row
->used
[area
]);
23465 start
= max (0, start
);
23466 start
= min (end
, start
);
23468 /* Translate X to frame coordinates. Set last_x to the right
23469 end of the drawing area. */
23470 if (row
->full_width_p
)
23472 /* X is relative to the left edge of W, without scroll bars
23474 area_left
= WINDOW_LEFT_EDGE_X (w
);
23475 last_x
= WINDOW_LEFT_EDGE_X (w
) + WINDOW_TOTAL_WIDTH (w
);
23479 area_left
= window_box_left (w
, area
);
23480 last_x
= area_left
+ window_box_width (w
, area
);
23484 /* Build a doubly-linked list of glyph_string structures between
23485 head and tail from what we have to draw. Note that the macro
23486 BUILD_GLYPH_STRINGS will modify its start parameter. That's
23487 the reason we use a separate variable `i'. */
23489 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
23491 x_reached
= tail
->x
+ tail
->background_width
;
23495 /* If there are any glyphs with lbearing < 0 or rbearing > width in
23496 the row, redraw some glyphs in front or following the glyph
23497 strings built above. */
23498 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
23500 struct glyph_string
*h
, *t
;
23501 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
23502 int mouse_beg_col
IF_LINT (= 0), mouse_end_col
IF_LINT (= 0);
23503 int check_mouse_face
= 0;
23506 /* If mouse highlighting is on, we may need to draw adjacent
23507 glyphs using mouse-face highlighting. */
23508 if (area
== TEXT_AREA
&& row
->mouse_face_p
23509 && hlinfo
->mouse_face_beg_row
>= 0
23510 && hlinfo
->mouse_face_end_row
>= 0)
23512 struct glyph_row
*mouse_beg_row
, *mouse_end_row
;
23514 mouse_beg_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
23515 mouse_end_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
23517 if (row
>= mouse_beg_row
&& row
<= mouse_end_row
)
23519 check_mouse_face
= 1;
23520 mouse_beg_col
= (row
== mouse_beg_row
)
23521 ? hlinfo
->mouse_face_beg_col
: 0;
23522 mouse_end_col
= (row
== mouse_end_row
)
23523 ? hlinfo
->mouse_face_end_col
23524 : row
->used
[TEXT_AREA
];
23528 /* Compute overhangs for all glyph strings. */
23529 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
23530 for (s
= head
; s
; s
= s
->next
)
23531 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
23533 /* Prepend glyph strings for glyphs in front of the first glyph
23534 string that are overwritten because of the first glyph
23535 string's left overhang. The background of all strings
23536 prepended must be drawn because the first glyph string
23538 i
= left_overwritten (head
);
23541 enum draw_glyphs_face overlap_hl
;
23543 /* If this row contains mouse highlighting, attempt to draw
23544 the overlapped glyphs with the correct highlight. This
23545 code fails if the overlap encompasses more than one glyph
23546 and mouse-highlight spans only some of these glyphs.
23547 However, making it work perfectly involves a lot more
23548 code, and I don't know if the pathological case occurs in
23549 practice, so we'll stick to this for now. --- cyd */
23550 if (check_mouse_face
23551 && mouse_beg_col
< start
&& mouse_end_col
> i
)
23552 overlap_hl
= DRAW_MOUSE_FACE
;
23554 overlap_hl
= DRAW_NORMAL_TEXT
;
23557 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
23558 overlap_hl
, dummy_x
, last_x
);
23560 compute_overhangs_and_x (t
, head
->x
, 1);
23561 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
23565 /* Prepend glyph strings for glyphs in front of the first glyph
23566 string that overwrite that glyph string because of their
23567 right overhang. For these strings, only the foreground must
23568 be drawn, because it draws over the glyph string at `head'.
23569 The background must not be drawn because this would overwrite
23570 right overhangs of preceding glyphs for which no glyph
23572 i
= left_overwriting (head
);
23575 enum draw_glyphs_face overlap_hl
;
23577 if (check_mouse_face
23578 && mouse_beg_col
< start
&& mouse_end_col
> i
)
23579 overlap_hl
= DRAW_MOUSE_FACE
;
23581 overlap_hl
= DRAW_NORMAL_TEXT
;
23584 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
23585 overlap_hl
, dummy_x
, last_x
);
23586 for (s
= h
; s
; s
= s
->next
)
23587 s
->background_filled_p
= 1;
23588 compute_overhangs_and_x (t
, head
->x
, 1);
23589 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
23592 /* Append glyphs strings for glyphs following the last glyph
23593 string tail that are overwritten by tail. The background of
23594 these strings has to be drawn because tail's foreground draws
23596 i
= right_overwritten (tail
);
23599 enum draw_glyphs_face overlap_hl
;
23601 if (check_mouse_face
23602 && mouse_beg_col
< i
&& mouse_end_col
> end
)
23603 overlap_hl
= DRAW_MOUSE_FACE
;
23605 overlap_hl
= DRAW_NORMAL_TEXT
;
23607 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
23608 overlap_hl
, x
, last_x
);
23609 /* Because BUILD_GLYPH_STRINGS updates the first argument,
23610 we don't have `end = i;' here. */
23611 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
23612 append_glyph_string_lists (&head
, &tail
, h
, t
);
23616 /* Append glyph strings for glyphs following the last glyph
23617 string tail that overwrite tail. The foreground of such
23618 glyphs has to be drawn because it writes into the background
23619 of tail. The background must not be drawn because it could
23620 paint over the foreground of following glyphs. */
23621 i
= right_overwriting (tail
);
23624 enum draw_glyphs_face overlap_hl
;
23625 if (check_mouse_face
23626 && mouse_beg_col
< i
&& mouse_end_col
> end
)
23627 overlap_hl
= DRAW_MOUSE_FACE
;
23629 overlap_hl
= DRAW_NORMAL_TEXT
;
23632 i
++; /* We must include the Ith glyph. */
23633 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
23634 overlap_hl
, x
, last_x
);
23635 for (s
= h
; s
; s
= s
->next
)
23636 s
->background_filled_p
= 1;
23637 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
23638 append_glyph_string_lists (&head
, &tail
, h
, t
);
23640 if (clip_head
|| clip_tail
)
23641 for (s
= head
; s
; s
= s
->next
)
23643 s
->clip_head
= clip_head
;
23644 s
->clip_tail
= clip_tail
;
23648 /* Draw all strings. */
23649 for (s
= head
; s
; s
= s
->next
)
23650 FRAME_RIF (f
)->draw_glyph_string (s
);
23653 /* When focus a sole frame and move horizontally, this sets on_p to 0
23654 causing a failure to erase prev cursor position. */
23655 if (area
== TEXT_AREA
23656 && !row
->full_width_p
23657 /* When drawing overlapping rows, only the glyph strings'
23658 foreground is drawn, which doesn't erase a cursor
23662 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
23663 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
23664 : (tail
? tail
->x
+ tail
->background_width
: x
));
23668 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
23669 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
23673 /* Value is the x-position up to which drawn, relative to AREA of W.
23674 This doesn't include parts drawn because of overhangs. */
23675 if (row
->full_width_p
)
23676 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
23678 x_reached
-= area_left
;
23680 RELEASE_HDC (hdc
, f
);
23685 /* Expand row matrix if too narrow. Don't expand if area
23688 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
23690 if (!fonts_changed_p \
23691 && (it->glyph_row->glyphs[area] \
23692 < it->glyph_row->glyphs[area + 1])) \
23694 it->w->ncols_scale_factor++; \
23695 fonts_changed_p = 1; \
23699 /* Store one glyph for IT->char_to_display in IT->glyph_row.
23700 Called from x_produce_glyphs when IT->glyph_row is non-null. */
23703 append_glyph (struct it
*it
)
23705 struct glyph
*glyph
;
23706 enum glyph_row_area area
= it
->area
;
23708 eassert (it
->glyph_row
);
23709 eassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
23711 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23712 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23714 /* If the glyph row is reversed, we need to prepend the glyph
23715 rather than append it. */
23716 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
23720 /* Make room for the additional glyph. */
23721 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
23723 glyph
= it
->glyph_row
->glyphs
[area
];
23725 glyph
->charpos
= CHARPOS (it
->position
);
23726 glyph
->object
= it
->object
;
23727 if (it
->pixel_width
> 0)
23729 glyph
->pixel_width
= it
->pixel_width
;
23730 glyph
->padding_p
= 0;
23734 /* Assure at least 1-pixel width. Otherwise, cursor can't
23735 be displayed correctly. */
23736 glyph
->pixel_width
= 1;
23737 glyph
->padding_p
= 1;
23739 glyph
->ascent
= it
->ascent
;
23740 glyph
->descent
= it
->descent
;
23741 glyph
->voffset
= it
->voffset
;
23742 glyph
->type
= CHAR_GLYPH
;
23743 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23744 glyph
->multibyte_p
= it
->multibyte_p
;
23745 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23746 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23747 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
23748 || it
->phys_descent
> it
->descent
);
23749 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
23750 glyph
->face_id
= it
->face_id
;
23751 glyph
->u
.ch
= it
->char_to_display
;
23752 glyph
->slice
.img
= null_glyph_slice
;
23753 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
23756 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
23757 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
23759 glyph
->bidi_type
= it
->bidi_it
.type
;
23763 glyph
->resolved_level
= 0;
23764 glyph
->bidi_type
= UNKNOWN_BT
;
23766 ++it
->glyph_row
->used
[area
];
23769 IT_EXPAND_MATRIX_WIDTH (it
, area
);
23772 /* Store one glyph for the composition IT->cmp_it.id in
23773 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
23777 append_composite_glyph (struct it
*it
)
23779 struct glyph
*glyph
;
23780 enum glyph_row_area area
= it
->area
;
23782 eassert (it
->glyph_row
);
23784 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23785 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23787 /* If the glyph row is reversed, we need to prepend the glyph
23788 rather than append it. */
23789 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
23793 /* Make room for the new glyph. */
23794 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
23796 glyph
= it
->glyph_row
->glyphs
[it
->area
];
23798 glyph
->charpos
= it
->cmp_it
.charpos
;
23799 glyph
->object
= it
->object
;
23800 glyph
->pixel_width
= it
->pixel_width
;
23801 glyph
->ascent
= it
->ascent
;
23802 glyph
->descent
= it
->descent
;
23803 glyph
->voffset
= it
->voffset
;
23804 glyph
->type
= COMPOSITE_GLYPH
;
23805 if (it
->cmp_it
.ch
< 0)
23807 glyph
->u
.cmp
.automatic
= 0;
23808 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
23809 glyph
->slice
.cmp
.from
= glyph
->slice
.cmp
.to
= 0;
23813 glyph
->u
.cmp
.automatic
= 1;
23814 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
23815 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
23816 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
23818 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23819 glyph
->multibyte_p
= it
->multibyte_p
;
23820 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23821 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23822 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
23823 || it
->phys_descent
> it
->descent
);
23824 glyph
->padding_p
= 0;
23825 glyph
->glyph_not_available_p
= 0;
23826 glyph
->face_id
= it
->face_id
;
23827 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
23830 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
23831 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
23833 glyph
->bidi_type
= it
->bidi_it
.type
;
23835 ++it
->glyph_row
->used
[area
];
23838 IT_EXPAND_MATRIX_WIDTH (it
, area
);
23842 /* Change IT->ascent and IT->height according to the setting of
23846 take_vertical_position_into_account (struct it
*it
)
23850 if (it
->voffset
< 0)
23851 /* Increase the ascent so that we can display the text higher
23853 it
->ascent
-= it
->voffset
;
23855 /* Increase the descent so that we can display the text lower
23857 it
->descent
+= it
->voffset
;
23862 /* Produce glyphs/get display metrics for the image IT is loaded with.
23863 See the description of struct display_iterator in dispextern.h for
23864 an overview of struct display_iterator. */
23867 produce_image_glyph (struct it
*it
)
23871 int glyph_ascent
, crop
;
23872 struct glyph_slice slice
;
23874 eassert (it
->what
== IT_IMAGE
);
23876 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23878 /* Make sure X resources of the face is loaded. */
23879 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
23881 if (it
->image_id
< 0)
23883 /* Fringe bitmap. */
23884 it
->ascent
= it
->phys_ascent
= 0;
23885 it
->descent
= it
->phys_descent
= 0;
23886 it
->pixel_width
= 0;
23891 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
23893 /* Make sure X resources of the image is loaded. */
23894 prepare_image_for_display (it
->f
, img
);
23896 slice
.x
= slice
.y
= 0;
23897 slice
.width
= img
->width
;
23898 slice
.height
= img
->height
;
23900 if (INTEGERP (it
->slice
.x
))
23901 slice
.x
= XINT (it
->slice
.x
);
23902 else if (FLOATP (it
->slice
.x
))
23903 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
23905 if (INTEGERP (it
->slice
.y
))
23906 slice
.y
= XINT (it
->slice
.y
);
23907 else if (FLOATP (it
->slice
.y
))
23908 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
23910 if (INTEGERP (it
->slice
.width
))
23911 slice
.width
= XINT (it
->slice
.width
);
23912 else if (FLOATP (it
->slice
.width
))
23913 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
23915 if (INTEGERP (it
->slice
.height
))
23916 slice
.height
= XINT (it
->slice
.height
);
23917 else if (FLOATP (it
->slice
.height
))
23918 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
23920 if (slice
.x
>= img
->width
)
23921 slice
.x
= img
->width
;
23922 if (slice
.y
>= img
->height
)
23923 slice
.y
= img
->height
;
23924 if (slice
.x
+ slice
.width
>= img
->width
)
23925 slice
.width
= img
->width
- slice
.x
;
23926 if (slice
.y
+ slice
.height
> img
->height
)
23927 slice
.height
= img
->height
- slice
.y
;
23929 if (slice
.width
== 0 || slice
.height
== 0)
23932 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
23934 it
->descent
= slice
.height
- glyph_ascent
;
23936 it
->descent
+= img
->vmargin
;
23937 if (slice
.y
+ slice
.height
== img
->height
)
23938 it
->descent
+= img
->vmargin
;
23939 it
->phys_descent
= it
->descent
;
23941 it
->pixel_width
= slice
.width
;
23943 it
->pixel_width
+= img
->hmargin
;
23944 if (slice
.x
+ slice
.width
== img
->width
)
23945 it
->pixel_width
+= img
->hmargin
;
23947 /* It's quite possible for images to have an ascent greater than
23948 their height, so don't get confused in that case. */
23949 if (it
->descent
< 0)
23954 if (face
->box
!= FACE_NO_BOX
)
23956 if (face
->box_line_width
> 0)
23959 it
->ascent
+= face
->box_line_width
;
23960 if (slice
.y
+ slice
.height
== img
->height
)
23961 it
->descent
+= face
->box_line_width
;
23964 if (it
->start_of_box_run_p
&& slice
.x
== 0)
23965 it
->pixel_width
+= eabs (face
->box_line_width
);
23966 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
23967 it
->pixel_width
+= eabs (face
->box_line_width
);
23970 take_vertical_position_into_account (it
);
23972 /* Automatically crop wide image glyphs at right edge so we can
23973 draw the cursor on same display row. */
23974 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
23975 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
23977 it
->pixel_width
-= crop
;
23978 slice
.width
-= crop
;
23983 struct glyph
*glyph
;
23984 enum glyph_row_area area
= it
->area
;
23986 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23987 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23989 glyph
->charpos
= CHARPOS (it
->position
);
23990 glyph
->object
= it
->object
;
23991 glyph
->pixel_width
= it
->pixel_width
;
23992 glyph
->ascent
= glyph_ascent
;
23993 glyph
->descent
= it
->descent
;
23994 glyph
->voffset
= it
->voffset
;
23995 glyph
->type
= IMAGE_GLYPH
;
23996 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23997 glyph
->multibyte_p
= it
->multibyte_p
;
23998 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23999 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24000 glyph
->overlaps_vertically_p
= 0;
24001 glyph
->padding_p
= 0;
24002 glyph
->glyph_not_available_p
= 0;
24003 glyph
->face_id
= it
->face_id
;
24004 glyph
->u
.img_id
= img
->id
;
24005 glyph
->slice
.img
= slice
;
24006 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24009 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24010 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24012 glyph
->bidi_type
= it
->bidi_it
.type
;
24014 ++it
->glyph_row
->used
[area
];
24017 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24022 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
24023 of the glyph, WIDTH and HEIGHT are the width and height of the
24024 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
24027 append_stretch_glyph (struct it
*it
, Lisp_Object object
,
24028 int width
, int height
, int ascent
)
24030 struct glyph
*glyph
;
24031 enum glyph_row_area area
= it
->area
;
24033 eassert (ascent
>= 0 && ascent
<= height
);
24035 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24036 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24038 /* If the glyph row is reversed, we need to prepend the glyph
24039 rather than append it. */
24040 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24044 /* Make room for the additional glyph. */
24045 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
24047 glyph
= it
->glyph_row
->glyphs
[area
];
24049 glyph
->charpos
= CHARPOS (it
->position
);
24050 glyph
->object
= object
;
24051 glyph
->pixel_width
= width
;
24052 glyph
->ascent
= ascent
;
24053 glyph
->descent
= height
- ascent
;
24054 glyph
->voffset
= it
->voffset
;
24055 glyph
->type
= STRETCH_GLYPH
;
24056 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24057 glyph
->multibyte_p
= it
->multibyte_p
;
24058 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24059 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24060 glyph
->overlaps_vertically_p
= 0;
24061 glyph
->padding_p
= 0;
24062 glyph
->glyph_not_available_p
= 0;
24063 glyph
->face_id
= it
->face_id
;
24064 glyph
->u
.stretch
.ascent
= ascent
;
24065 glyph
->u
.stretch
.height
= height
;
24066 glyph
->slice
.img
= null_glyph_slice
;
24067 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24070 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24071 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24073 glyph
->bidi_type
= it
->bidi_it
.type
;
24077 glyph
->resolved_level
= 0;
24078 glyph
->bidi_type
= UNKNOWN_BT
;
24080 ++it
->glyph_row
->used
[area
];
24083 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24086 #endif /* HAVE_WINDOW_SYSTEM */
24088 /* Produce a stretch glyph for iterator IT. IT->object is the value
24089 of the glyph property displayed. The value must be a list
24090 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
24093 1. `:width WIDTH' specifies that the space should be WIDTH *
24094 canonical char width wide. WIDTH may be an integer or floating
24097 2. `:relative-width FACTOR' specifies that the width of the stretch
24098 should be computed from the width of the first character having the
24099 `glyph' property, and should be FACTOR times that width.
24101 3. `:align-to HPOS' specifies that the space should be wide enough
24102 to reach HPOS, a value in canonical character units.
24104 Exactly one of the above pairs must be present.
24106 4. `:height HEIGHT' specifies that the height of the stretch produced
24107 should be HEIGHT, measured in canonical character units.
24109 5. `:relative-height FACTOR' specifies that the height of the
24110 stretch should be FACTOR times the height of the characters having
24111 the glyph property.
24113 Either none or exactly one of 4 or 5 must be present.
24115 6. `:ascent ASCENT' specifies that ASCENT percent of the height
24116 of the stretch should be used for the ascent of the stretch.
24117 ASCENT must be in the range 0 <= ASCENT <= 100. */
24120 produce_stretch_glyph (struct it
*it
)
24122 /* (space :width WIDTH :height HEIGHT ...) */
24123 Lisp_Object prop
, plist
;
24124 int width
= 0, height
= 0, align_to
= -1;
24125 int zero_width_ok_p
= 0;
24127 struct font
*font
= NULL
;
24129 #ifdef HAVE_WINDOW_SYSTEM
24131 int zero_height_ok_p
= 0;
24133 if (FRAME_WINDOW_P (it
->f
))
24135 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24136 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24137 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
24141 /* List should start with `space'. */
24142 eassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
24143 plist
= XCDR (it
->object
);
24145 /* Compute the width of the stretch. */
24146 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
24147 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
24149 /* Absolute width `:width WIDTH' specified and valid. */
24150 zero_width_ok_p
= 1;
24153 #ifdef HAVE_WINDOW_SYSTEM
24154 else if (FRAME_WINDOW_P (it
->f
)
24155 && (prop
= Fplist_get (plist
, QCrelative_width
), NUMVAL (prop
) > 0))
24157 /* Relative width `:relative-width FACTOR' specified and valid.
24158 Compute the width of the characters having the `glyph'
24161 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
24164 if (it
->multibyte_p
)
24165 it2
.c
= it2
.char_to_display
= STRING_CHAR_AND_LENGTH (p
, it2
.len
);
24168 it2
.c
= it2
.char_to_display
= *p
, it2
.len
= 1;
24169 if (! ASCII_CHAR_P (it2
.c
))
24170 it2
.char_to_display
= BYTE8_TO_CHAR (it2
.c
);
24173 it2
.glyph_row
= NULL
;
24174 it2
.what
= IT_CHARACTER
;
24175 x_produce_glyphs (&it2
);
24176 width
= NUMVAL (prop
) * it2
.pixel_width
;
24178 #endif /* HAVE_WINDOW_SYSTEM */
24179 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
24180 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
24182 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
24183 align_to
= (align_to
< 0
24185 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
24186 else if (align_to
< 0)
24187 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
24188 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
24189 zero_width_ok_p
= 1;
24192 /* Nothing specified -> width defaults to canonical char width. */
24193 width
= FRAME_COLUMN_WIDTH (it
->f
);
24195 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
24198 #ifdef HAVE_WINDOW_SYSTEM
24199 /* Compute height. */
24200 if (FRAME_WINDOW_P (it
->f
))
24202 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
24203 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
24206 zero_height_ok_p
= 1;
24208 else if (prop
= Fplist_get (plist
, QCrelative_height
),
24210 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
24212 height
= FONT_HEIGHT (font
);
24214 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
24217 /* Compute percentage of height used for ascent. If
24218 `:ascent ASCENT' is present and valid, use that. Otherwise,
24219 derive the ascent from the font in use. */
24220 if (prop
= Fplist_get (plist
, QCascent
),
24221 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
24222 ascent
= height
* NUMVAL (prop
) / 100.0;
24223 else if (!NILP (prop
)
24224 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
24225 ascent
= min (max (0, (int)tem
), height
);
24227 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
24230 #endif /* HAVE_WINDOW_SYSTEM */
24233 if (width
> 0 && it
->line_wrap
!= TRUNCATE
24234 && it
->current_x
+ width
> it
->last_visible_x
)
24236 width
= it
->last_visible_x
- it
->current_x
;
24237 #ifdef HAVE_WINDOW_SYSTEM
24238 /* Subtract one more pixel from the stretch width, but only on
24239 GUI frames, since on a TTY each glyph is one "pixel" wide. */
24240 width
-= FRAME_WINDOW_P (it
->f
);
24244 if (width
> 0 && height
> 0 && it
->glyph_row
)
24246 Lisp_Object o_object
= it
->object
;
24247 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
24250 if (!STRINGP (object
))
24251 object
= it
->w
->buffer
;
24252 #ifdef HAVE_WINDOW_SYSTEM
24253 if (FRAME_WINDOW_P (it
->f
))
24254 append_stretch_glyph (it
, object
, width
, height
, ascent
);
24258 it
->object
= object
;
24259 it
->char_to_display
= ' ';
24260 it
->pixel_width
= it
->len
= 1;
24262 tty_append_glyph (it
);
24263 it
->object
= o_object
;
24267 it
->pixel_width
= width
;
24268 #ifdef HAVE_WINDOW_SYSTEM
24269 if (FRAME_WINDOW_P (it
->f
))
24271 it
->ascent
= it
->phys_ascent
= ascent
;
24272 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
24273 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
24274 take_vertical_position_into_account (it
);
24278 it
->nglyphs
= width
;
24281 /* Get information about special display element WHAT in an
24282 environment described by IT. WHAT is one of IT_TRUNCATION or
24283 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
24284 non-null glyph_row member. This function ensures that fields like
24285 face_id, c, len of IT are left untouched. */
24288 produce_special_glyphs (struct it
*it
, enum display_element_type what
)
24295 temp_it
.object
= make_number (0);
24296 memset (&temp_it
.current
, 0, sizeof temp_it
.current
);
24298 if (what
== IT_CONTINUATION
)
24300 /* Continuation glyph. For R2L lines, we mirror it by hand. */
24301 if (it
->bidi_it
.paragraph_dir
== R2L
)
24302 SET_GLYPH_FROM_CHAR (glyph
, '/');
24304 SET_GLYPH_FROM_CHAR (glyph
, '\\');
24306 && (gc
= DISP_CONTINUE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
24308 /* FIXME: Should we mirror GC for R2L lines? */
24309 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
24310 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
24313 else if (what
== IT_TRUNCATION
)
24315 /* Truncation glyph. */
24316 SET_GLYPH_FROM_CHAR (glyph
, '$');
24318 && (gc
= DISP_TRUNC_GLYPH (it
->dp
), GLYPH_CODE_P (gc
)))
24320 /* FIXME: Should we mirror GC for R2L lines? */
24321 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
24322 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
24328 #ifdef HAVE_WINDOW_SYSTEM
24329 /* On a GUI frame, when the right fringe (left fringe for R2L rows)
24330 is turned off, we precede the truncation/continuation glyphs by a
24331 stretch glyph whose width is computed such that these special
24332 glyphs are aligned at the window margin, even when very different
24333 fonts are used in different glyph rows. */
24334 if (FRAME_WINDOW_P (temp_it
.f
)
24335 /* init_iterator calls this with it->glyph_row == NULL, and it
24336 wants only the pixel width of the truncation/continuation
24338 && temp_it
.glyph_row
24339 /* insert_left_trunc_glyphs calls us at the beginning of the
24340 row, and it has its own calculation of the stretch glyph
24342 && temp_it
.glyph_row
->used
[TEXT_AREA
] > 0
24343 && (temp_it
.glyph_row
->reversed_p
24344 ? WINDOW_LEFT_FRINGE_WIDTH (temp_it
.w
)
24345 : WINDOW_RIGHT_FRINGE_WIDTH (temp_it
.w
)) == 0)
24347 int stretch_width
= temp_it
.last_visible_x
- temp_it
.current_x
;
24349 if (stretch_width
> 0)
24351 struct face
*face
= FACE_FROM_ID (temp_it
.f
, temp_it
.face_id
);
24352 struct font
*font
=
24353 face
->font
? face
->font
: FRAME_FONT (temp_it
.f
);
24354 int stretch_ascent
=
24355 (((temp_it
.ascent
+ temp_it
.descent
)
24356 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
24358 append_stretch_glyph (&temp_it
, make_number (0), stretch_width
,
24359 temp_it
.ascent
+ temp_it
.descent
,
24366 temp_it
.what
= IT_CHARACTER
;
24368 temp_it
.c
= temp_it
.char_to_display
= GLYPH_CHAR (glyph
);
24369 temp_it
.face_id
= GLYPH_FACE (glyph
);
24370 temp_it
.len
= CHAR_BYTES (temp_it
.c
);
24372 PRODUCE_GLYPHS (&temp_it
);
24373 it
->pixel_width
= temp_it
.pixel_width
;
24374 it
->nglyphs
= temp_it
.pixel_width
;
24377 #ifdef HAVE_WINDOW_SYSTEM
24379 /* Calculate line-height and line-spacing properties.
24380 An integer value specifies explicit pixel value.
24381 A float value specifies relative value to current face height.
24382 A cons (float . face-name) specifies relative value to
24383 height of specified face font.
24385 Returns height in pixels, or nil. */
24389 calc_line_height_property (struct it
*it
, Lisp_Object val
, struct font
*font
,
24390 int boff
, int override
)
24392 Lisp_Object face_name
= Qnil
;
24393 int ascent
, descent
, height
;
24395 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
24400 face_name
= XCAR (val
);
24402 if (!NUMBERP (val
))
24403 val
= make_number (1);
24404 if (NILP (face_name
))
24406 height
= it
->ascent
+ it
->descent
;
24411 if (NILP (face_name
))
24413 font
= FRAME_FONT (it
->f
);
24414 boff
= FRAME_BASELINE_OFFSET (it
->f
);
24416 else if (EQ (face_name
, Qt
))
24425 face_id
= lookup_named_face (it
->f
, face_name
, 0);
24427 return make_number (-1);
24429 face
= FACE_FROM_ID (it
->f
, face_id
);
24432 return make_number (-1);
24433 boff
= font
->baseline_offset
;
24434 if (font
->vertical_centering
)
24435 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
24438 ascent
= FONT_BASE (font
) + boff
;
24439 descent
= FONT_DESCENT (font
) - boff
;
24443 it
->override_ascent
= ascent
;
24444 it
->override_descent
= descent
;
24445 it
->override_boff
= boff
;
24448 height
= ascent
+ descent
;
24452 height
= (int)(XFLOAT_DATA (val
) * height
);
24453 else if (INTEGERP (val
))
24454 height
*= XINT (val
);
24456 return make_number (height
);
24460 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
24461 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
24462 and only if this is for a character for which no font was found.
24464 If the display method (it->glyphless_method) is
24465 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
24466 length of the acronym or the hexadecimal string, UPPER_XOFF and
24467 UPPER_YOFF are pixel offsets for the upper part of the string,
24468 LOWER_XOFF and LOWER_YOFF are for the lower part.
24470 For the other display methods, LEN through LOWER_YOFF are zero. */
24473 append_glyphless_glyph (struct it
*it
, int face_id
, int for_no_font
, int len
,
24474 short upper_xoff
, short upper_yoff
,
24475 short lower_xoff
, short lower_yoff
)
24477 struct glyph
*glyph
;
24478 enum glyph_row_area area
= it
->area
;
24480 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
24481 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
24483 /* If the glyph row is reversed, we need to prepend the glyph
24484 rather than append it. */
24485 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
24489 /* Make room for the additional glyph. */
24490 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
24492 glyph
= it
->glyph_row
->glyphs
[area
];
24494 glyph
->charpos
= CHARPOS (it
->position
);
24495 glyph
->object
= it
->object
;
24496 glyph
->pixel_width
= it
->pixel_width
;
24497 glyph
->ascent
= it
->ascent
;
24498 glyph
->descent
= it
->descent
;
24499 glyph
->voffset
= it
->voffset
;
24500 glyph
->type
= GLYPHLESS_GLYPH
;
24501 glyph
->u
.glyphless
.method
= it
->glyphless_method
;
24502 glyph
->u
.glyphless
.for_no_font
= for_no_font
;
24503 glyph
->u
.glyphless
.len
= len
;
24504 glyph
->u
.glyphless
.ch
= it
->c
;
24505 glyph
->slice
.glyphless
.upper_xoff
= upper_xoff
;
24506 glyph
->slice
.glyphless
.upper_yoff
= upper_yoff
;
24507 glyph
->slice
.glyphless
.lower_xoff
= lower_xoff
;
24508 glyph
->slice
.glyphless
.lower_yoff
= lower_yoff
;
24509 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
24510 glyph
->multibyte_p
= it
->multibyte_p
;
24511 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
24512 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
24513 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
24514 || it
->phys_descent
> it
->descent
);
24515 glyph
->padding_p
= 0;
24516 glyph
->glyph_not_available_p
= 0;
24517 glyph
->face_id
= face_id
;
24518 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
24521 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
24522 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
24524 glyph
->bidi_type
= it
->bidi_it
.type
;
24526 ++it
->glyph_row
->used
[area
];
24529 IT_EXPAND_MATRIX_WIDTH (it
, area
);
24533 /* Produce a glyph for a glyphless character for iterator IT.
24534 IT->glyphless_method specifies which method to use for displaying
24535 the character. See the description of enum
24536 glyphless_display_method in dispextern.h for the detail.
24538 FOR_NO_FONT is nonzero if and only if this is for a character for
24539 which no font was found. ACRONYM, if non-nil, is an acronym string
24540 for the character. */
24543 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
24548 int base_width
, base_height
, width
, height
;
24549 short upper_xoff
, upper_yoff
, lower_xoff
, lower_yoff
;
24552 /* Get the metrics of the base font. We always refer to the current
24554 face
= FACE_FROM_ID (it
->f
, it
->face_id
)->ascii_face
;
24555 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24556 it
->ascent
= FONT_BASE (font
) + font
->baseline_offset
;
24557 it
->descent
= FONT_DESCENT (font
) - font
->baseline_offset
;
24558 base_height
= it
->ascent
+ it
->descent
;
24559 base_width
= font
->average_width
;
24561 /* Get a face ID for the glyph by utilizing a cache (the same way as
24562 done for `escape-glyph' in get_next_display_element). */
24563 if (it
->f
== last_glyphless_glyph_frame
24564 && it
->face_id
== last_glyphless_glyph_face_id
)
24566 face_id
= last_glyphless_glyph_merged_face_id
;
24570 /* Merge the `glyphless-char' face into the current face. */
24571 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
24572 last_glyphless_glyph_frame
= it
->f
;
24573 last_glyphless_glyph_face_id
= it
->face_id
;
24574 last_glyphless_glyph_merged_face_id
= face_id
;
24577 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
24579 it
->pixel_width
= THIN_SPACE_WIDTH
;
24581 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
24583 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
24585 width
= CHAR_WIDTH (it
->c
);
24588 else if (width
> 4)
24590 it
->pixel_width
= base_width
* width
;
24592 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
24598 unsigned int code
[6];
24600 int ascent
, descent
;
24601 struct font_metrics metrics_upper
, metrics_lower
;
24603 face
= FACE_FROM_ID (it
->f
, face_id
);
24604 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
24605 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
24607 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
24609 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
24610 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
24611 if (CONSP (acronym
))
24612 acronym
= XCAR (acronym
);
24613 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
24617 eassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
24618 sprintf (buf
, "%0*X", it
->c
< 0x10000 ? 4 : 6, it
->c
);
24621 for (len
= 0; str
[len
] && ASCII_BYTE_P (str
[len
]) && len
< 6; len
++)
24622 code
[len
] = font
->driver
->encode_char (font
, str
[len
]);
24623 upper_len
= (len
+ 1) / 2;
24624 font
->driver
->text_extents (font
, code
, upper_len
,
24626 font
->driver
->text_extents (font
, code
+ upper_len
, len
- upper_len
,
24631 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
24632 width
= max (metrics_upper
.width
, metrics_lower
.width
) + 4;
24633 upper_xoff
= upper_yoff
= 2; /* the typical case */
24634 if (base_width
>= width
)
24636 /* Align the upper to the left, the lower to the right. */
24637 it
->pixel_width
= base_width
;
24638 lower_xoff
= base_width
- 2 - metrics_lower
.width
;
24642 /* Center the shorter one. */
24643 it
->pixel_width
= width
;
24644 if (metrics_upper
.width
>= metrics_lower
.width
)
24645 lower_xoff
= (width
- metrics_lower
.width
) / 2;
24648 /* FIXME: This code doesn't look right. It formerly was
24649 missing the "lower_xoff = 0;", which couldn't have
24650 been right since it left lower_xoff uninitialized. */
24652 upper_xoff
= (width
- metrics_upper
.width
) / 2;
24656 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
24657 top, bottom, and between upper and lower strings. */
24658 height
= (metrics_upper
.ascent
+ metrics_upper
.descent
24659 + metrics_lower
.ascent
+ metrics_lower
.descent
) + 5;
24660 /* Center vertically.
24661 H:base_height, D:base_descent
24662 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
24664 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
24665 descent = D - H/2 + h/2;
24666 lower_yoff = descent - 2 - ld;
24667 upper_yoff = lower_yoff - la - 1 - ud; */
24668 ascent
= - (it
->descent
- (base_height
+ height
+ 1) / 2);
24669 descent
= it
->descent
- (base_height
- height
) / 2;
24670 lower_yoff
= descent
- 2 - metrics_lower
.descent
;
24671 upper_yoff
= (lower_yoff
- metrics_lower
.ascent
- 1
24672 - metrics_upper
.descent
);
24673 /* Don't make the height shorter than the base height. */
24674 if (height
> base_height
)
24676 it
->ascent
= ascent
;
24677 it
->descent
= descent
;
24681 it
->phys_ascent
= it
->ascent
;
24682 it
->phys_descent
= it
->descent
;
24684 append_glyphless_glyph (it
, face_id
, for_no_font
, len
,
24685 upper_xoff
, upper_yoff
,
24686 lower_xoff
, lower_yoff
);
24688 take_vertical_position_into_account (it
);
24693 Produce glyphs/get display metrics for the display element IT is
24694 loaded with. See the description of struct it in dispextern.h
24695 for an overview of struct it. */
24698 x_produce_glyphs (struct it
*it
)
24700 int extra_line_spacing
= it
->extra_line_spacing
;
24702 it
->glyph_not_available_p
= 0;
24704 if (it
->what
== IT_CHARACTER
)
24707 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24708 struct font
*font
= face
->font
;
24709 struct font_metrics
*pcm
= NULL
;
24710 int boff
; /* baseline offset */
24714 /* When no suitable font is found, display this character by
24715 the method specified in the first extra slot of
24716 Vglyphless_char_display. */
24717 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
24719 eassert (it
->what
== IT_GLYPHLESS
);
24720 produce_glyphless_glyph (it
, 1, STRINGP (acronym
) ? acronym
: Qnil
);
24724 boff
= font
->baseline_offset
;
24725 if (font
->vertical_centering
)
24726 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
24728 if (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t')
24734 if (it
->override_ascent
>= 0)
24736 it
->ascent
= it
->override_ascent
;
24737 it
->descent
= it
->override_descent
;
24738 boff
= it
->override_boff
;
24742 it
->ascent
= FONT_BASE (font
) + boff
;
24743 it
->descent
= FONT_DESCENT (font
) - boff
;
24746 if (get_char_glyph_code (it
->char_to_display
, font
, &char2b
))
24748 pcm
= get_per_char_metric (font
, &char2b
);
24749 if (pcm
->width
== 0
24750 && pcm
->rbearing
== 0 && pcm
->lbearing
== 0)
24756 it
->phys_ascent
= pcm
->ascent
+ boff
;
24757 it
->phys_descent
= pcm
->descent
- boff
;
24758 it
->pixel_width
= pcm
->width
;
24762 it
->glyph_not_available_p
= 1;
24763 it
->phys_ascent
= it
->ascent
;
24764 it
->phys_descent
= it
->descent
;
24765 it
->pixel_width
= font
->space_width
;
24768 if (it
->constrain_row_ascent_descent_p
)
24770 if (it
->descent
> it
->max_descent
)
24772 it
->ascent
+= it
->descent
- it
->max_descent
;
24773 it
->descent
= it
->max_descent
;
24775 if (it
->ascent
> it
->max_ascent
)
24777 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
24778 it
->ascent
= it
->max_ascent
;
24780 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
24781 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
24782 extra_line_spacing
= 0;
24785 /* If this is a space inside a region of text with
24786 `space-width' property, change its width. */
24787 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
24789 it
->pixel_width
*= XFLOATINT (it
->space_width
);
24791 /* If face has a box, add the box thickness to the character
24792 height. If character has a box line to the left and/or
24793 right, add the box line width to the character's width. */
24794 if (face
->box
!= FACE_NO_BOX
)
24796 int thick
= face
->box_line_width
;
24800 it
->ascent
+= thick
;
24801 it
->descent
+= thick
;
24806 if (it
->start_of_box_run_p
)
24807 it
->pixel_width
+= thick
;
24808 if (it
->end_of_box_run_p
)
24809 it
->pixel_width
+= thick
;
24812 /* If face has an overline, add the height of the overline
24813 (1 pixel) and a 1 pixel margin to the character height. */
24814 if (face
->overline_p
)
24815 it
->ascent
+= overline_margin
;
24817 if (it
->constrain_row_ascent_descent_p
)
24819 if (it
->ascent
> it
->max_ascent
)
24820 it
->ascent
= it
->max_ascent
;
24821 if (it
->descent
> it
->max_descent
)
24822 it
->descent
= it
->max_descent
;
24825 take_vertical_position_into_account (it
);
24827 /* If we have to actually produce glyphs, do it. */
24832 /* Translate a space with a `space-width' property
24833 into a stretch glyph. */
24834 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
24835 / FONT_HEIGHT (font
));
24836 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
24837 it
->ascent
+ it
->descent
, ascent
);
24842 /* If characters with lbearing or rbearing are displayed
24843 in this line, record that fact in a flag of the
24844 glyph row. This is used to optimize X output code. */
24845 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
24846 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
24848 if (! stretched_p
&& it
->pixel_width
== 0)
24849 /* We assure that all visible glyphs have at least 1-pixel
24851 it
->pixel_width
= 1;
24853 else if (it
->char_to_display
== '\n')
24855 /* A newline has no width, but we need the height of the
24856 line. But if previous part of the line sets a height,
24857 don't increase that height */
24859 Lisp_Object height
;
24860 Lisp_Object total_height
= Qnil
;
24862 it
->override_ascent
= -1;
24863 it
->pixel_width
= 0;
24866 height
= get_it_property (it
, Qline_height
);
24867 /* Split (line-height total-height) list */
24869 && CONSP (XCDR (height
))
24870 && NILP (XCDR (XCDR (height
))))
24872 total_height
= XCAR (XCDR (height
));
24873 height
= XCAR (height
);
24875 height
= calc_line_height_property (it
, height
, font
, boff
, 1);
24877 if (it
->override_ascent
>= 0)
24879 it
->ascent
= it
->override_ascent
;
24880 it
->descent
= it
->override_descent
;
24881 boff
= it
->override_boff
;
24885 it
->ascent
= FONT_BASE (font
) + boff
;
24886 it
->descent
= FONT_DESCENT (font
) - boff
;
24889 if (EQ (height
, Qt
))
24891 if (it
->descent
> it
->max_descent
)
24893 it
->ascent
+= it
->descent
- it
->max_descent
;
24894 it
->descent
= it
->max_descent
;
24896 if (it
->ascent
> it
->max_ascent
)
24898 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
24899 it
->ascent
= it
->max_ascent
;
24901 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
24902 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
24903 it
->constrain_row_ascent_descent_p
= 1;
24904 extra_line_spacing
= 0;
24908 Lisp_Object spacing
;
24910 it
->phys_ascent
= it
->ascent
;
24911 it
->phys_descent
= it
->descent
;
24913 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
24914 && face
->box
!= FACE_NO_BOX
24915 && face
->box_line_width
> 0)
24917 it
->ascent
+= face
->box_line_width
;
24918 it
->descent
+= face
->box_line_width
;
24921 && XINT (height
) > it
->ascent
+ it
->descent
)
24922 it
->ascent
= XINT (height
) - it
->descent
;
24924 if (!NILP (total_height
))
24925 spacing
= calc_line_height_property (it
, total_height
, font
, boff
, 0);
24928 spacing
= get_it_property (it
, Qline_spacing
);
24929 spacing
= calc_line_height_property (it
, spacing
, font
, boff
, 0);
24931 if (INTEGERP (spacing
))
24933 extra_line_spacing
= XINT (spacing
);
24934 if (!NILP (total_height
))
24935 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
24939 else /* i.e. (it->char_to_display == '\t') */
24941 if (font
->space_width
> 0)
24943 int tab_width
= it
->tab_width
* font
->space_width
;
24944 int x
= it
->current_x
+ it
->continuation_lines_width
;
24945 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
24947 /* If the distance from the current position to the next tab
24948 stop is less than a space character width, use the
24949 tab stop after that. */
24950 if (next_tab_x
- x
< font
->space_width
)
24951 next_tab_x
+= tab_width
;
24953 it
->pixel_width
= next_tab_x
- x
;
24955 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
24956 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
24960 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
24961 it
->ascent
+ it
->descent
, it
->ascent
);
24966 it
->pixel_width
= 0;
24971 else if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
< 0)
24973 /* A static composition.
24975 Note: A composition is represented as one glyph in the
24976 glyph matrix. There are no padding glyphs.
24978 Important note: pixel_width, ascent, and descent are the
24979 values of what is drawn by draw_glyphs (i.e. the values of
24980 the overall glyphs composed). */
24981 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
24982 int boff
; /* baseline offset */
24983 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
24984 int glyph_len
= cmp
->glyph_len
;
24985 struct font
*font
= face
->font
;
24989 /* If we have not yet calculated pixel size data of glyphs of
24990 the composition for the current face font, calculate them
24991 now. Theoretically, we have to check all fonts for the
24992 glyphs, but that requires much time and memory space. So,
24993 here we check only the font of the first glyph. This may
24994 lead to incorrect display, but it's very rare, and C-l
24995 (recenter-top-bottom) can correct the display anyway. */
24996 if (! cmp
->font
|| cmp
->font
!= font
)
24998 /* Ascent and descent of the font of the first character
24999 of this composition (adjusted by baseline offset).
25000 Ascent and descent of overall glyphs should not be less
25001 than these, respectively. */
25002 int font_ascent
, font_descent
, font_height
;
25003 /* Bounding box of the overall glyphs. */
25004 int leftmost
, rightmost
, lowest
, highest
;
25005 int lbearing
, rbearing
;
25006 int i
, width
, ascent
, descent
;
25007 int left_padded
= 0, right_padded
= 0;
25008 int c
IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
25010 struct font_metrics
*pcm
;
25011 int font_not_found_p
;
25014 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
25015 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
25017 if (glyph_len
< cmp
->glyph_len
)
25019 for (i
= 0; i
< glyph_len
; i
++)
25021 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
25023 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
25028 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
25029 : IT_CHARPOS (*it
));
25030 /* If no suitable font is found, use the default font. */
25031 font_not_found_p
= font
== NULL
;
25032 if (font_not_found_p
)
25034 face
= face
->ascii_face
;
25037 boff
= font
->baseline_offset
;
25038 if (font
->vertical_centering
)
25039 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
25040 font_ascent
= FONT_BASE (font
) + boff
;
25041 font_descent
= FONT_DESCENT (font
) - boff
;
25042 font_height
= FONT_HEIGHT (font
);
25047 if (! font_not_found_p
)
25049 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
25051 pcm
= get_per_char_metric (font
, &char2b
);
25054 /* Initialize the bounding box. */
25057 width
= cmp
->glyph_len
> 0 ? pcm
->width
: 0;
25058 ascent
= pcm
->ascent
;
25059 descent
= pcm
->descent
;
25060 lbearing
= pcm
->lbearing
;
25061 rbearing
= pcm
->rbearing
;
25065 width
= cmp
->glyph_len
> 0 ? font
->space_width
: 0;
25066 ascent
= FONT_BASE (font
);
25067 descent
= FONT_DESCENT (font
);
25074 lowest
= - descent
+ boff
;
25075 highest
= ascent
+ boff
;
25077 if (! font_not_found_p
25078 && font
->default_ascent
25079 && CHAR_TABLE_P (Vuse_default_ascent
)
25080 && !NILP (Faref (Vuse_default_ascent
,
25081 make_number (it
->char_to_display
))))
25082 highest
= font
->default_ascent
+ boff
;
25084 /* Draw the first glyph at the normal position. It may be
25085 shifted to right later if some other glyphs are drawn
25087 cmp
->offsets
[i
* 2] = 0;
25088 cmp
->offsets
[i
* 2 + 1] = boff
;
25089 cmp
->lbearing
= lbearing
;
25090 cmp
->rbearing
= rbearing
;
25092 /* Set cmp->offsets for the remaining glyphs. */
25093 for (i
++; i
< glyph_len
; i
++)
25095 int left
, right
, btm
, top
;
25096 int ch
= COMPOSITION_GLYPH (cmp
, i
);
25098 struct face
*this_face
;
25102 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
25103 this_face
= FACE_FROM_ID (it
->f
, face_id
);
25104 font
= this_face
->font
;
25110 get_char_face_and_encoding (it
->f
, ch
, face_id
,
25112 pcm
= get_per_char_metric (font
, &char2b
);
25115 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
25118 width
= pcm
->width
;
25119 ascent
= pcm
->ascent
;
25120 descent
= pcm
->descent
;
25121 lbearing
= pcm
->lbearing
;
25122 rbearing
= pcm
->rbearing
;
25123 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
25125 /* Relative composition with or without
25126 alternate chars. */
25127 left
= (leftmost
+ rightmost
- width
) / 2;
25128 btm
= - descent
+ boff
;
25129 if (font
->relative_compose
25130 && (! CHAR_TABLE_P (Vignore_relative_composition
)
25131 || NILP (Faref (Vignore_relative_composition
,
25132 make_number (ch
)))))
25135 if (- descent
>= font
->relative_compose
)
25136 /* One extra pixel between two glyphs. */
25138 else if (ascent
<= 0)
25139 /* One extra pixel between two glyphs. */
25140 btm
= lowest
- 1 - ascent
- descent
;
25145 /* A composition rule is specified by an integer
25146 value that encodes global and new reference
25147 points (GREF and NREF). GREF and NREF are
25148 specified by numbers as below:
25150 0---1---2 -- ascent
25154 9--10--11 -- center
25156 ---3---4---5--- baseline
25158 6---7---8 -- descent
25160 int rule
= COMPOSITION_RULE (cmp
, i
);
25161 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
25163 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
25164 grefx
= gref
% 3, nrefx
= nref
% 3;
25165 grefy
= gref
/ 3, nrefy
= nref
/ 3;
25167 xoff
= font_height
* (xoff
- 128) / 256;
25169 yoff
= font_height
* (yoff
- 128) / 256;
25172 + grefx
* (rightmost
- leftmost
) / 2
25173 - nrefx
* width
/ 2
25176 btm
= ((grefy
== 0 ? highest
25178 : grefy
== 2 ? lowest
25179 : (highest
+ lowest
) / 2)
25180 - (nrefy
== 0 ? ascent
+ descent
25181 : nrefy
== 1 ? descent
- boff
25183 : (ascent
+ descent
) / 2)
25187 cmp
->offsets
[i
* 2] = left
;
25188 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
25190 /* Update the bounding box of the overall glyphs. */
25193 right
= left
+ width
;
25194 if (left
< leftmost
)
25196 if (right
> rightmost
)
25199 top
= btm
+ descent
+ ascent
;
25205 if (cmp
->lbearing
> left
+ lbearing
)
25206 cmp
->lbearing
= left
+ lbearing
;
25207 if (cmp
->rbearing
< left
+ rbearing
)
25208 cmp
->rbearing
= left
+ rbearing
;
25212 /* If there are glyphs whose x-offsets are negative,
25213 shift all glyphs to the right and make all x-offsets
25217 for (i
= 0; i
< cmp
->glyph_len
; i
++)
25218 cmp
->offsets
[i
* 2] -= leftmost
;
25219 rightmost
-= leftmost
;
25220 cmp
->lbearing
-= leftmost
;
25221 cmp
->rbearing
-= leftmost
;
25224 if (left_padded
&& cmp
->lbearing
< 0)
25226 for (i
= 0; i
< cmp
->glyph_len
; i
++)
25227 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
25228 rightmost
-= cmp
->lbearing
;
25229 cmp
->rbearing
-= cmp
->lbearing
;
25232 if (right_padded
&& rightmost
< cmp
->rbearing
)
25234 rightmost
= cmp
->rbearing
;
25237 cmp
->pixel_width
= rightmost
;
25238 cmp
->ascent
= highest
;
25239 cmp
->descent
= - lowest
;
25240 if (cmp
->ascent
< font_ascent
)
25241 cmp
->ascent
= font_ascent
;
25242 if (cmp
->descent
< font_descent
)
25243 cmp
->descent
= font_descent
;
25247 && (cmp
->lbearing
< 0
25248 || cmp
->rbearing
> cmp
->pixel_width
))
25249 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
25251 it
->pixel_width
= cmp
->pixel_width
;
25252 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
25253 it
->descent
= it
->phys_descent
= cmp
->descent
;
25254 if (face
->box
!= FACE_NO_BOX
)
25256 int thick
= face
->box_line_width
;
25260 it
->ascent
+= thick
;
25261 it
->descent
+= thick
;
25266 if (it
->start_of_box_run_p
)
25267 it
->pixel_width
+= thick
;
25268 if (it
->end_of_box_run_p
)
25269 it
->pixel_width
+= thick
;
25272 /* If face has an overline, add the height of the overline
25273 (1 pixel) and a 1 pixel margin to the character height. */
25274 if (face
->overline_p
)
25275 it
->ascent
+= overline_margin
;
25277 take_vertical_position_into_account (it
);
25278 if (it
->ascent
< 0)
25280 if (it
->descent
< 0)
25283 if (it
->glyph_row
&& cmp
->glyph_len
> 0)
25284 append_composite_glyph (it
);
25286 else if (it
->what
== IT_COMPOSITION
)
25288 /* A dynamic (automatic) composition. */
25289 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
25290 Lisp_Object gstring
;
25291 struct font_metrics metrics
;
25295 gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
25297 = composition_gstring_width (gstring
, it
->cmp_it
.from
, it
->cmp_it
.to
,
25300 && (metrics
.lbearing
< 0 || metrics
.rbearing
> metrics
.width
))
25301 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
25302 it
->ascent
= it
->phys_ascent
= metrics
.ascent
;
25303 it
->descent
= it
->phys_descent
= metrics
.descent
;
25304 if (face
->box
!= FACE_NO_BOX
)
25306 int thick
= face
->box_line_width
;
25310 it
->ascent
+= thick
;
25311 it
->descent
+= thick
;
25316 if (it
->start_of_box_run_p
)
25317 it
->pixel_width
+= thick
;
25318 if (it
->end_of_box_run_p
)
25319 it
->pixel_width
+= thick
;
25321 /* If face has an overline, add the height of the overline
25322 (1 pixel) and a 1 pixel margin to the character height. */
25323 if (face
->overline_p
)
25324 it
->ascent
+= overline_margin
;
25325 take_vertical_position_into_account (it
);
25326 if (it
->ascent
< 0)
25328 if (it
->descent
< 0)
25332 append_composite_glyph (it
);
25334 else if (it
->what
== IT_GLYPHLESS
)
25335 produce_glyphless_glyph (it
, 0, Qnil
);
25336 else if (it
->what
== IT_IMAGE
)
25337 produce_image_glyph (it
);
25338 else if (it
->what
== IT_STRETCH
)
25339 produce_stretch_glyph (it
);
25342 /* Accumulate dimensions. Note: can't assume that it->descent > 0
25343 because this isn't true for images with `:ascent 100'. */
25344 eassert (it
->ascent
>= 0 && it
->descent
>= 0);
25345 if (it
->area
== TEXT_AREA
)
25346 it
->current_x
+= it
->pixel_width
;
25348 if (extra_line_spacing
> 0)
25350 it
->descent
+= extra_line_spacing
;
25351 if (extra_line_spacing
> it
->max_extra_line_spacing
)
25352 it
->max_extra_line_spacing
= extra_line_spacing
;
25355 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
25356 it
->max_descent
= max (it
->max_descent
, it
->descent
);
25357 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
25358 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
25362 Output LEN glyphs starting at START at the nominal cursor position.
25363 Advance the nominal cursor over the text. The global variable
25364 updated_window contains the window being updated, updated_row is
25365 the glyph row being updated, and updated_area is the area of that
25366 row being updated. */
25369 x_write_glyphs (struct glyph
*start
, int len
)
25371 int x
, hpos
, chpos
= updated_window
->phys_cursor
.hpos
;
25373 eassert (updated_window
&& updated_row
);
25374 /* When the window is hscrolled, cursor hpos can legitimately be out
25375 of bounds, but we draw the cursor at the corresponding window
25376 margin in that case. */
25377 if (!updated_row
->reversed_p
&& chpos
< 0)
25379 if (updated_row
->reversed_p
&& chpos
>= updated_row
->used
[TEXT_AREA
])
25380 chpos
= updated_row
->used
[TEXT_AREA
] - 1;
25384 /* Write glyphs. */
25386 hpos
= start
- updated_row
->glyphs
[updated_area
];
25387 x
= draw_glyphs (updated_window
, output_cursor
.x
,
25388 updated_row
, updated_area
,
25390 DRAW_NORMAL_TEXT
, 0);
25392 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
25393 if (updated_area
== TEXT_AREA
25394 && updated_window
->phys_cursor_on_p
25395 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
25397 && chpos
< hpos
+ len
)
25398 updated_window
->phys_cursor_on_p
= 0;
25402 /* Advance the output cursor. */
25403 output_cursor
.hpos
+= len
;
25404 output_cursor
.x
= x
;
25409 Insert LEN glyphs from START at the nominal cursor position. */
25412 x_insert_glyphs (struct glyph
*start
, int len
)
25416 int line_height
, shift_by_width
, shifted_region_width
;
25417 struct glyph_row
*row
;
25418 struct glyph
*glyph
;
25419 int frame_x
, frame_y
;
25422 eassert (updated_window
&& updated_row
);
25424 w
= updated_window
;
25425 f
= XFRAME (WINDOW_FRAME (w
));
25427 /* Get the height of the line we are in. */
25429 line_height
= row
->height
;
25431 /* Get the width of the glyphs to insert. */
25432 shift_by_width
= 0;
25433 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
25434 shift_by_width
+= glyph
->pixel_width
;
25436 /* Get the width of the region to shift right. */
25437 shifted_region_width
= (window_box_width (w
, updated_area
)
25442 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
25443 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
25445 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
25446 line_height
, shift_by_width
);
25448 /* Write the glyphs. */
25449 hpos
= start
- row
->glyphs
[updated_area
];
25450 draw_glyphs (w
, output_cursor
.x
, row
, updated_area
,
25452 DRAW_NORMAL_TEXT
, 0);
25454 /* Advance the output cursor. */
25455 output_cursor
.hpos
+= len
;
25456 output_cursor
.x
+= shift_by_width
;
25462 Erase the current text line from the nominal cursor position
25463 (inclusive) to pixel column TO_X (exclusive). The idea is that
25464 everything from TO_X onward is already erased.
25466 TO_X is a pixel position relative to updated_area of
25467 updated_window. TO_X == -1 means clear to the end of this area. */
25470 x_clear_end_of_line (int to_x
)
25473 struct window
*w
= updated_window
;
25474 int max_x
, min_y
, max_y
;
25475 int from_x
, from_y
, to_y
;
25477 eassert (updated_window
&& updated_row
);
25478 f
= XFRAME (w
->frame
);
25480 if (updated_row
->full_width_p
)
25481 max_x
= WINDOW_TOTAL_WIDTH (w
);
25483 max_x
= window_box_width (w
, updated_area
);
25484 max_y
= window_text_bottom_y (w
);
25486 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
25487 of window. For TO_X > 0, truncate to end of drawing area. */
25493 to_x
= min (to_x
, max_x
);
25495 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
25497 /* Notice if the cursor will be cleared by this operation. */
25498 if (!updated_row
->full_width_p
)
25499 notice_overwritten_cursor (w
, updated_area
,
25500 output_cursor
.x
, -1,
25502 MATRIX_ROW_BOTTOM_Y (updated_row
));
25504 from_x
= output_cursor
.x
;
25506 /* Translate to frame coordinates. */
25507 if (updated_row
->full_width_p
)
25509 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
25510 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
25514 int area_left
= window_box_left (w
, updated_area
);
25515 from_x
+= area_left
;
25519 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
25520 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
25521 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
25523 /* Prevent inadvertently clearing to end of the X window. */
25524 if (to_x
> from_x
&& to_y
> from_y
)
25527 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
25528 to_x
- from_x
, to_y
- from_y
);
25533 #endif /* HAVE_WINDOW_SYSTEM */
25537 /***********************************************************************
25539 ***********************************************************************/
25541 /* Value is the internal representation of the specified cursor type
25542 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
25543 of the bar cursor. */
25545 static enum text_cursor_kinds
25546 get_specified_cursor_type (Lisp_Object arg
, int *width
)
25548 enum text_cursor_kinds type
;
25553 if (EQ (arg
, Qbox
))
25554 return FILLED_BOX_CURSOR
;
25556 if (EQ (arg
, Qhollow
))
25557 return HOLLOW_BOX_CURSOR
;
25559 if (EQ (arg
, Qbar
))
25566 && EQ (XCAR (arg
), Qbar
)
25567 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
25569 *width
= XINT (XCDR (arg
));
25573 if (EQ (arg
, Qhbar
))
25576 return HBAR_CURSOR
;
25580 && EQ (XCAR (arg
), Qhbar
)
25581 && RANGED_INTEGERP (0, XCDR (arg
), INT_MAX
))
25583 *width
= XINT (XCDR (arg
));
25584 return HBAR_CURSOR
;
25587 /* Treat anything unknown as "hollow box cursor".
25588 It was bad to signal an error; people have trouble fixing
25589 .Xdefaults with Emacs, when it has something bad in it. */
25590 type
= HOLLOW_BOX_CURSOR
;
25595 /* Set the default cursor types for specified frame. */
25597 set_frame_cursor_types (struct frame
*f
, Lisp_Object arg
)
25602 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
25603 FRAME_CURSOR_WIDTH (f
) = width
;
25605 /* By default, set up the blink-off state depending on the on-state. */
25607 tem
= Fassoc (arg
, Vblink_cursor_alist
);
25610 FRAME_BLINK_OFF_CURSOR (f
)
25611 = get_specified_cursor_type (XCDR (tem
), &width
);
25612 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
25615 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
25619 #ifdef HAVE_WINDOW_SYSTEM
25621 /* Return the cursor we want to be displayed in window W. Return
25622 width of bar/hbar cursor through WIDTH arg. Return with
25623 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
25624 (i.e. if the `system caret' should track this cursor).
25626 In a mini-buffer window, we want the cursor only to appear if we
25627 are reading input from this window. For the selected window, we
25628 want the cursor type given by the frame parameter or buffer local
25629 setting of cursor-type. If explicitly marked off, draw no cursor.
25630 In all other cases, we want a hollow box cursor. */
25632 static enum text_cursor_kinds
25633 get_window_cursor_type (struct window
*w
, struct glyph
*glyph
, int *width
,
25634 int *active_cursor
)
25636 struct frame
*f
= XFRAME (w
->frame
);
25637 struct buffer
*b
= XBUFFER (w
->buffer
);
25638 int cursor_type
= DEFAULT_CURSOR
;
25639 Lisp_Object alt_cursor
;
25640 int non_selected
= 0;
25642 *active_cursor
= 1;
25645 if (cursor_in_echo_area
25646 && FRAME_HAS_MINIBUF_P (f
)
25647 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
25649 if (w
== XWINDOW (echo_area_window
))
25651 if (EQ (BVAR (b
, cursor_type
), Qt
) || NILP (BVAR (b
, cursor_type
)))
25653 *width
= FRAME_CURSOR_WIDTH (f
);
25654 return FRAME_DESIRED_CURSOR (f
);
25657 return get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
25660 *active_cursor
= 0;
25664 /* Detect a nonselected window or nonselected frame. */
25665 else if (w
!= XWINDOW (f
->selected_window
)
25666 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
25668 *active_cursor
= 0;
25670 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
25676 /* Never display a cursor in a window in which cursor-type is nil. */
25677 if (NILP (BVAR (b
, cursor_type
)))
25680 /* Get the normal cursor type for this window. */
25681 if (EQ (BVAR (b
, cursor_type
), Qt
))
25683 cursor_type
= FRAME_DESIRED_CURSOR (f
);
25684 *width
= FRAME_CURSOR_WIDTH (f
);
25687 cursor_type
= get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
25689 /* Use cursor-in-non-selected-windows instead
25690 for non-selected window or frame. */
25693 alt_cursor
= BVAR (b
, cursor_in_non_selected_windows
);
25694 if (!EQ (Qt
, alt_cursor
))
25695 return get_specified_cursor_type (alt_cursor
, width
);
25696 /* t means modify the normal cursor type. */
25697 if (cursor_type
== FILLED_BOX_CURSOR
)
25698 cursor_type
= HOLLOW_BOX_CURSOR
;
25699 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
25701 return cursor_type
;
25704 /* Use normal cursor if not blinked off. */
25705 if (!w
->cursor_off_p
)
25707 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
25709 if (cursor_type
== FILLED_BOX_CURSOR
)
25711 /* Using a block cursor on large images can be very annoying.
25712 So use a hollow cursor for "large" images.
25713 If image is not transparent (no mask), also use hollow cursor. */
25714 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
25715 if (img
!= NULL
&& IMAGEP (img
->spec
))
25717 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
25718 where N = size of default frame font size.
25719 This should cover most of the "tiny" icons people may use. */
25721 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
25722 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
25723 cursor_type
= HOLLOW_BOX_CURSOR
;
25726 else if (cursor_type
!= NO_CURSOR
)
25728 /* Display current only supports BOX and HOLLOW cursors for images.
25729 So for now, unconditionally use a HOLLOW cursor when cursor is
25730 not a solid box cursor. */
25731 cursor_type
= HOLLOW_BOX_CURSOR
;
25734 return cursor_type
;
25737 /* Cursor is blinked off, so determine how to "toggle" it. */
25739 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
25740 if ((alt_cursor
= Fassoc (BVAR (b
, cursor_type
), Vblink_cursor_alist
), !NILP (alt_cursor
)))
25741 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
25743 /* Then see if frame has specified a specific blink off cursor type. */
25744 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
25746 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
25747 return FRAME_BLINK_OFF_CURSOR (f
);
25751 /* Some people liked having a permanently visible blinking cursor,
25752 while others had very strong opinions against it. So it was
25753 decided to remove it. KFS 2003-09-03 */
25755 /* Finally perform built-in cursor blinking:
25756 filled box <-> hollow box
25757 wide [h]bar <-> narrow [h]bar
25758 narrow [h]bar <-> no cursor
25759 other type <-> no cursor */
25761 if (cursor_type
== FILLED_BOX_CURSOR
)
25762 return HOLLOW_BOX_CURSOR
;
25764 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
25767 return cursor_type
;
25775 /* Notice when the text cursor of window W has been completely
25776 overwritten by a drawing operation that outputs glyphs in AREA
25777 starting at X0 and ending at X1 in the line starting at Y0 and
25778 ending at Y1. X coordinates are area-relative. X1 < 0 means all
25779 the rest of the line after X0 has been written. Y coordinates
25780 are window-relative. */
25783 notice_overwritten_cursor (struct window
*w
, enum glyph_row_area area
,
25784 int x0
, int x1
, int y0
, int y1
)
25786 int cx0
, cx1
, cy0
, cy1
;
25787 struct glyph_row
*row
;
25789 if (!w
->phys_cursor_on_p
)
25791 if (area
!= TEXT_AREA
)
25794 if (w
->phys_cursor
.vpos
< 0
25795 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
25796 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
25797 !(row
->enabled_p
&& row
->displays_text_p
)))
25800 if (row
->cursor_in_fringe_p
)
25802 row
->cursor_in_fringe_p
= 0;
25803 draw_fringe_bitmap (w
, row
, row
->reversed_p
);
25804 w
->phys_cursor_on_p
= 0;
25808 cx0
= w
->phys_cursor
.x
;
25809 cx1
= cx0
+ w
->phys_cursor_width
;
25810 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
25813 /* The cursor image will be completely removed from the
25814 screen if the output area intersects the cursor area in
25815 y-direction. When we draw in [y0 y1[, and some part of
25816 the cursor is at y < y0, that part must have been drawn
25817 before. When scrolling, the cursor is erased before
25818 actually scrolling, so we don't come here. When not
25819 scrolling, the rows above the old cursor row must have
25820 changed, and in this case these rows must have written
25821 over the cursor image.
25823 Likewise if part of the cursor is below y1, with the
25824 exception of the cursor being in the first blank row at
25825 the buffer and window end because update_text_area
25826 doesn't draw that row. (Except when it does, but
25827 that's handled in update_text_area.) */
25829 cy0
= w
->phys_cursor
.y
;
25830 cy1
= cy0
+ w
->phys_cursor_height
;
25831 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
25834 w
->phys_cursor_on_p
= 0;
25837 #endif /* HAVE_WINDOW_SYSTEM */
25840 /************************************************************************
25842 ************************************************************************/
25844 #ifdef HAVE_WINDOW_SYSTEM
25847 Fix the display of area AREA of overlapping row ROW in window W
25848 with respect to the overlapping part OVERLAPS. */
25851 x_fix_overlapping_area (struct window
*w
, struct glyph_row
*row
,
25852 enum glyph_row_area area
, int overlaps
)
25859 for (i
= 0; i
< row
->used
[area
];)
25861 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
25863 int start
= i
, start_x
= x
;
25867 x
+= row
->glyphs
[area
][i
].pixel_width
;
25870 while (i
< row
->used
[area
]
25871 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
25873 draw_glyphs (w
, start_x
, row
, area
,
25875 DRAW_NORMAL_TEXT
, overlaps
);
25879 x
+= row
->glyphs
[area
][i
].pixel_width
;
25889 Draw the cursor glyph of window W in glyph row ROW. See the
25890 comment of draw_glyphs for the meaning of HL. */
25893 draw_phys_cursor_glyph (struct window
*w
, struct glyph_row
*row
,
25894 enum draw_glyphs_face hl
)
25896 /* If cursor hpos is out of bounds, don't draw garbage. This can
25897 happen in mini-buffer windows when switching between echo area
25898 glyphs and mini-buffer. */
25899 if ((row
->reversed_p
25900 ? (w
->phys_cursor
.hpos
>= 0)
25901 : (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])))
25903 int on_p
= w
->phys_cursor_on_p
;
25905 int hpos
= w
->phys_cursor
.hpos
;
25907 /* When the window is hscrolled, cursor hpos can legitimately be
25908 out of bounds, but we draw the cursor at the corresponding
25909 window margin in that case. */
25910 if (!row
->reversed_p
&& hpos
< 0)
25912 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
25913 hpos
= row
->used
[TEXT_AREA
] - 1;
25915 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
, hpos
, hpos
+ 1,
25917 w
->phys_cursor_on_p
= on_p
;
25919 if (hl
== DRAW_CURSOR
)
25920 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
25921 /* When we erase the cursor, and ROW is overlapped by other
25922 rows, make sure that these overlapping parts of other rows
25924 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
25926 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
25928 if (row
> w
->current_matrix
->rows
25929 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
25930 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
25931 OVERLAPS_ERASED_CURSOR
);
25933 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
25934 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
25935 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
25936 OVERLAPS_ERASED_CURSOR
);
25943 Erase the image of a cursor of window W from the screen. */
25946 erase_phys_cursor (struct window
*w
)
25948 struct frame
*f
= XFRAME (w
->frame
);
25949 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25950 int hpos
= w
->phys_cursor
.hpos
;
25951 int vpos
= w
->phys_cursor
.vpos
;
25952 int mouse_face_here_p
= 0;
25953 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
25954 struct glyph_row
*cursor_row
;
25955 struct glyph
*cursor_glyph
;
25956 enum draw_glyphs_face hl
;
25958 /* No cursor displayed or row invalidated => nothing to do on the
25960 if (w
->phys_cursor_type
== NO_CURSOR
)
25961 goto mark_cursor_off
;
25963 /* VPOS >= active_glyphs->nrows means that window has been resized.
25964 Don't bother to erase the cursor. */
25965 if (vpos
>= active_glyphs
->nrows
)
25966 goto mark_cursor_off
;
25968 /* If row containing cursor is marked invalid, there is nothing we
25970 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
25971 if (!cursor_row
->enabled_p
)
25972 goto mark_cursor_off
;
25974 /* If line spacing is > 0, old cursor may only be partially visible in
25975 window after split-window. So adjust visible height. */
25976 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
25977 window_text_bottom_y (w
) - cursor_row
->y
);
25979 /* If row is completely invisible, don't attempt to delete a cursor which
25980 isn't there. This can happen if cursor is at top of a window, and
25981 we switch to a buffer with a header line in that window. */
25982 if (cursor_row
->visible_height
<= 0)
25983 goto mark_cursor_off
;
25985 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
25986 if (cursor_row
->cursor_in_fringe_p
)
25988 cursor_row
->cursor_in_fringe_p
= 0;
25989 draw_fringe_bitmap (w
, cursor_row
, cursor_row
->reversed_p
);
25990 goto mark_cursor_off
;
25993 /* This can happen when the new row is shorter than the old one.
25994 In this case, either draw_glyphs or clear_end_of_line
25995 should have cleared the cursor. Note that we wouldn't be
25996 able to erase the cursor in this case because we don't have a
25997 cursor glyph at hand. */
25998 if ((cursor_row
->reversed_p
25999 ? (w
->phys_cursor
.hpos
< 0)
26000 : (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])))
26001 goto mark_cursor_off
;
26003 /* When the window is hscrolled, cursor hpos can legitimately be out
26004 of bounds, but we draw the cursor at the corresponding window
26005 margin in that case. */
26006 if (!cursor_row
->reversed_p
&& hpos
< 0)
26008 if (cursor_row
->reversed_p
&& hpos
>= cursor_row
->used
[TEXT_AREA
])
26009 hpos
= cursor_row
->used
[TEXT_AREA
] - 1;
26011 /* If the cursor is in the mouse face area, redisplay that when
26012 we clear the cursor. */
26013 if (! NILP (hlinfo
->mouse_face_window
)
26014 && coords_in_mouse_face_p (w
, hpos
, vpos
)
26015 /* Don't redraw the cursor's spot in mouse face if it is at the
26016 end of a line (on a newline). The cursor appears there, but
26017 mouse highlighting does not. */
26018 && cursor_row
->used
[TEXT_AREA
] > hpos
&& hpos
>= 0)
26019 mouse_face_here_p
= 1;
26021 /* Maybe clear the display under the cursor. */
26022 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
26025 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
26028 cursor_glyph
= get_phys_cursor_glyph (w
);
26029 if (cursor_glyph
== NULL
)
26030 goto mark_cursor_off
;
26032 width
= cursor_glyph
->pixel_width
;
26033 left_x
= window_box_left_offset (w
, TEXT_AREA
);
26034 x
= w
->phys_cursor
.x
;
26036 width
-= left_x
- x
;
26037 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
26038 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
26039 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
26042 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
26045 /* Erase the cursor by redrawing the character underneath it. */
26046 if (mouse_face_here_p
)
26047 hl
= DRAW_MOUSE_FACE
;
26049 hl
= DRAW_NORMAL_TEXT
;
26050 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
26053 w
->phys_cursor_on_p
= 0;
26054 w
->phys_cursor_type
= NO_CURSOR
;
26059 Display or clear cursor of window W. If ON is zero, clear the
26060 cursor. If it is non-zero, display the cursor. If ON is nonzero,
26061 where to put the cursor is specified by HPOS, VPOS, X and Y. */
26064 display_and_set_cursor (struct window
*w
, int on
,
26065 int hpos
, int vpos
, int x
, int y
)
26067 struct frame
*f
= XFRAME (w
->frame
);
26068 int new_cursor_type
;
26069 int new_cursor_width
;
26071 struct glyph_row
*glyph_row
;
26072 struct glyph
*glyph
;
26074 /* This is pointless on invisible frames, and dangerous on garbaged
26075 windows and frames; in the latter case, the frame or window may
26076 be in the midst of changing its size, and x and y may be off the
26078 if (! FRAME_VISIBLE_P (f
)
26079 || FRAME_GARBAGED_P (f
)
26080 || vpos
>= w
->current_matrix
->nrows
26081 || hpos
>= w
->current_matrix
->matrix_w
)
26084 /* If cursor is off and we want it off, return quickly. */
26085 if (!on
&& !w
->phys_cursor_on_p
)
26088 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26089 /* If cursor row is not enabled, we don't really know where to
26090 display the cursor. */
26091 if (!glyph_row
->enabled_p
)
26093 w
->phys_cursor_on_p
= 0;
26098 if (!glyph_row
->exact_window_width_line_p
26099 || (0 <= hpos
&& hpos
< glyph_row
->used
[TEXT_AREA
]))
26100 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
26102 eassert (input_blocked_p ());
26104 /* Set new_cursor_type to the cursor we want to be displayed. */
26105 new_cursor_type
= get_window_cursor_type (w
, glyph
,
26106 &new_cursor_width
, &active_cursor
);
26108 /* If cursor is currently being shown and we don't want it to be or
26109 it is in the wrong place, or the cursor type is not what we want,
26111 if (w
->phys_cursor_on_p
26113 || w
->phys_cursor
.x
!= x
26114 || w
->phys_cursor
.y
!= y
26115 || new_cursor_type
!= w
->phys_cursor_type
26116 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
26117 && new_cursor_width
!= w
->phys_cursor_width
)))
26118 erase_phys_cursor (w
);
26120 /* Don't check phys_cursor_on_p here because that flag is only set
26121 to zero in some cases where we know that the cursor has been
26122 completely erased, to avoid the extra work of erasing the cursor
26123 twice. In other words, phys_cursor_on_p can be 1 and the cursor
26124 still not be visible, or it has only been partly erased. */
26127 w
->phys_cursor_ascent
= glyph_row
->ascent
;
26128 w
->phys_cursor_height
= glyph_row
->height
;
26130 /* Set phys_cursor_.* before x_draw_.* is called because some
26131 of them may need the information. */
26132 w
->phys_cursor
.x
= x
;
26133 w
->phys_cursor
.y
= glyph_row
->y
;
26134 w
->phys_cursor
.hpos
= hpos
;
26135 w
->phys_cursor
.vpos
= vpos
;
26138 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
26139 new_cursor_type
, new_cursor_width
,
26140 on
, active_cursor
);
26144 /* Switch the display of W's cursor on or off, according to the value
26148 update_window_cursor (struct window
*w
, int on
)
26150 /* Don't update cursor in windows whose frame is in the process
26151 of being deleted. */
26152 if (w
->current_matrix
)
26154 int hpos
= w
->phys_cursor
.hpos
;
26155 int vpos
= w
->phys_cursor
.vpos
;
26156 struct glyph_row
*row
;
26158 if (vpos
>= w
->current_matrix
->nrows
26159 || hpos
>= w
->current_matrix
->matrix_w
)
26162 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26164 /* When the window is hscrolled, cursor hpos can legitimately be
26165 out of bounds, but we draw the cursor at the corresponding
26166 window margin in that case. */
26167 if (!row
->reversed_p
&& hpos
< 0)
26169 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26170 hpos
= row
->used
[TEXT_AREA
] - 1;
26173 display_and_set_cursor (w
, on
, hpos
, vpos
,
26174 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
26180 /* Call update_window_cursor with parameter ON_P on all leaf windows
26181 in the window tree rooted at W. */
26184 update_cursor_in_window_tree (struct window
*w
, int on_p
)
26188 if (!NILP (w
->hchild
))
26189 update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
26190 else if (!NILP (w
->vchild
))
26191 update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
26193 update_window_cursor (w
, on_p
);
26195 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
26201 Display the cursor on window W, or clear it, according to ON_P.
26202 Don't change the cursor's position. */
26205 x_update_cursor (struct frame
*f
, int on_p
)
26207 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
26212 Clear the cursor of window W to background color, and mark the
26213 cursor as not shown. This is used when the text where the cursor
26214 is about to be rewritten. */
26217 x_clear_cursor (struct window
*w
)
26219 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
26220 update_window_cursor (w
, 0);
26223 #endif /* HAVE_WINDOW_SYSTEM */
26225 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
26228 draw_row_with_mouse_face (struct window
*w
, int start_x
, struct glyph_row
*row
,
26229 int start_hpos
, int end_hpos
,
26230 enum draw_glyphs_face draw
)
26232 #ifdef HAVE_WINDOW_SYSTEM
26233 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
26235 draw_glyphs (w
, start_x
, row
, TEXT_AREA
, start_hpos
, end_hpos
, draw
, 0);
26239 #if defined (HAVE_GPM) || defined (MSDOS) || defined (WINDOWSNT)
26240 tty_draw_row_with_mouse_face (w
, row
, start_hpos
, end_hpos
, draw
);
26244 /* Display the active region described by mouse_face_* according to DRAW. */
26247 show_mouse_face (Mouse_HLInfo
*hlinfo
, enum draw_glyphs_face draw
)
26249 struct window
*w
= XWINDOW (hlinfo
->mouse_face_window
);
26250 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
26252 if (/* If window is in the process of being destroyed, don't bother
26254 w
->current_matrix
!= NULL
26255 /* Don't update mouse highlight if hidden */
26256 && (draw
!= DRAW_MOUSE_FACE
|| !hlinfo
->mouse_face_hidden
)
26257 /* Recognize when we are called to operate on rows that don't exist
26258 anymore. This can happen when a window is split. */
26259 && hlinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
26261 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
26262 struct glyph_row
*row
, *first
, *last
;
26264 first
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
26265 last
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
26267 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
26269 int start_hpos
, end_hpos
, start_x
;
26271 /* For all but the first row, the highlight starts at column 0. */
26274 /* R2L rows have BEG and END in reversed order, but the
26275 screen drawing geometry is always left to right. So
26276 we need to mirror the beginning and end of the
26277 highlighted area in R2L rows. */
26278 if (!row
->reversed_p
)
26280 start_hpos
= hlinfo
->mouse_face_beg_col
;
26281 start_x
= hlinfo
->mouse_face_beg_x
;
26283 else if (row
== last
)
26285 start_hpos
= hlinfo
->mouse_face_end_col
;
26286 start_x
= hlinfo
->mouse_face_end_x
;
26294 else if (row
->reversed_p
&& row
== last
)
26296 start_hpos
= hlinfo
->mouse_face_end_col
;
26297 start_x
= hlinfo
->mouse_face_end_x
;
26307 if (!row
->reversed_p
)
26308 end_hpos
= hlinfo
->mouse_face_end_col
;
26309 else if (row
== first
)
26310 end_hpos
= hlinfo
->mouse_face_beg_col
;
26313 end_hpos
= row
->used
[TEXT_AREA
];
26314 if (draw
== DRAW_NORMAL_TEXT
)
26315 row
->fill_line_p
= 1; /* Clear to end of line */
26318 else if (row
->reversed_p
&& row
== first
)
26319 end_hpos
= hlinfo
->mouse_face_beg_col
;
26322 end_hpos
= row
->used
[TEXT_AREA
];
26323 if (draw
== DRAW_NORMAL_TEXT
)
26324 row
->fill_line_p
= 1; /* Clear to end of line */
26327 if (end_hpos
> start_hpos
)
26329 draw_row_with_mouse_face (w
, start_x
, row
,
26330 start_hpos
, end_hpos
, draw
);
26333 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
26337 #ifdef HAVE_WINDOW_SYSTEM
26338 /* When we've written over the cursor, arrange for it to
26339 be displayed again. */
26340 if (FRAME_WINDOW_P (f
)
26341 && phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
26343 int hpos
= w
->phys_cursor
.hpos
;
26345 /* When the window is hscrolled, cursor hpos can legitimately be
26346 out of bounds, but we draw the cursor at the corresponding
26347 window margin in that case. */
26348 if (!row
->reversed_p
&& hpos
< 0)
26350 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26351 hpos
= row
->used
[TEXT_AREA
] - 1;
26354 display_and_set_cursor (w
, 1, hpos
, w
->phys_cursor
.vpos
,
26355 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
26358 #endif /* HAVE_WINDOW_SYSTEM */
26361 #ifdef HAVE_WINDOW_SYSTEM
26362 /* Change the mouse cursor. */
26363 if (FRAME_WINDOW_P (f
))
26365 if (draw
== DRAW_NORMAL_TEXT
26366 && !EQ (hlinfo
->mouse_face_window
, f
->tool_bar_window
))
26367 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
26368 else if (draw
== DRAW_MOUSE_FACE
)
26369 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
26371 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
26373 #endif /* HAVE_WINDOW_SYSTEM */
26377 Clear out the mouse-highlighted active region.
26378 Redraw it un-highlighted first. Value is non-zero if mouse
26379 face was actually drawn unhighlighted. */
26382 clear_mouse_face (Mouse_HLInfo
*hlinfo
)
26386 if (!hlinfo
->mouse_face_hidden
&& !NILP (hlinfo
->mouse_face_window
))
26388 show_mouse_face (hlinfo
, DRAW_NORMAL_TEXT
);
26392 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
26393 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
26394 hlinfo
->mouse_face_window
= Qnil
;
26395 hlinfo
->mouse_face_overlay
= Qnil
;
26399 /* Return non-zero if the coordinates HPOS and VPOS on windows W are
26400 within the mouse face on that window. */
26402 coords_in_mouse_face_p (struct window
*w
, int hpos
, int vpos
)
26404 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
26406 /* Quickly resolve the easy cases. */
26407 if (!(WINDOWP (hlinfo
->mouse_face_window
)
26408 && XWINDOW (hlinfo
->mouse_face_window
) == w
))
26410 if (vpos
< hlinfo
->mouse_face_beg_row
26411 || vpos
> hlinfo
->mouse_face_end_row
)
26413 if (vpos
> hlinfo
->mouse_face_beg_row
26414 && vpos
< hlinfo
->mouse_face_end_row
)
26417 if (!MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
)
26419 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
26421 if (hlinfo
->mouse_face_beg_col
<= hpos
&& hpos
< hlinfo
->mouse_face_end_col
)
26424 else if ((vpos
== hlinfo
->mouse_face_beg_row
26425 && hpos
>= hlinfo
->mouse_face_beg_col
)
26426 || (vpos
== hlinfo
->mouse_face_end_row
26427 && hpos
< hlinfo
->mouse_face_end_col
))
26432 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
26434 if (hlinfo
->mouse_face_end_col
< hpos
&& hpos
<= hlinfo
->mouse_face_beg_col
)
26437 else if ((vpos
== hlinfo
->mouse_face_beg_row
26438 && hpos
<= hlinfo
->mouse_face_beg_col
)
26439 || (vpos
== hlinfo
->mouse_face_end_row
26440 && hpos
> hlinfo
->mouse_face_end_col
))
26448 Non-zero if physical cursor of window W is within mouse face. */
26451 cursor_in_mouse_face_p (struct window
*w
)
26453 int hpos
= w
->phys_cursor
.hpos
;
26454 int vpos
= w
->phys_cursor
.vpos
;
26455 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
26457 /* When the window is hscrolled, cursor hpos can legitimately be out
26458 of bounds, but we draw the cursor at the corresponding window
26459 margin in that case. */
26460 if (!row
->reversed_p
&& hpos
< 0)
26462 if (row
->reversed_p
&& hpos
>= row
->used
[TEXT_AREA
])
26463 hpos
= row
->used
[TEXT_AREA
] - 1;
26465 return coords_in_mouse_face_p (w
, hpos
, vpos
);
26470 /* Find the glyph rows START_ROW and END_ROW of window W that display
26471 characters between buffer positions START_CHARPOS and END_CHARPOS
26472 (excluding END_CHARPOS). DISP_STRING is a display string that
26473 covers these buffer positions. This is similar to
26474 row_containing_pos, but is more accurate when bidi reordering makes
26475 buffer positions change non-linearly with glyph rows. */
26477 rows_from_pos_range (struct window
*w
,
26478 ptrdiff_t start_charpos
, ptrdiff_t end_charpos
,
26479 Lisp_Object disp_string
,
26480 struct glyph_row
**start
, struct glyph_row
**end
)
26482 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26483 int last_y
= window_text_bottom_y (w
);
26484 struct glyph_row
*row
;
26489 while (!first
->enabled_p
26490 && first
< MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
26493 /* Find the START row. */
26495 row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
;
26498 /* A row can potentially be the START row if the range of the
26499 characters it displays intersects the range
26500 [START_CHARPOS..END_CHARPOS). */
26501 if (! ((start_charpos
< MATRIX_ROW_START_CHARPOS (row
)
26502 && end_charpos
< MATRIX_ROW_START_CHARPOS (row
))
26503 /* See the commentary in row_containing_pos, for the
26504 explanation of the complicated way to check whether
26505 some position is beyond the end of the characters
26506 displayed by a row. */
26507 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (row
)
26508 || (start_charpos
== MATRIX_ROW_END_CHARPOS (row
)
26509 && !row
->ends_at_zv_p
26510 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
26511 && (end_charpos
> MATRIX_ROW_END_CHARPOS (row
)
26512 || (end_charpos
== MATRIX_ROW_END_CHARPOS (row
)
26513 && !row
->ends_at_zv_p
26514 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))))
26516 /* Found a candidate row. Now make sure at least one of the
26517 glyphs it displays has a charpos from the range
26518 [START_CHARPOS..END_CHARPOS).
26520 This is not obvious because bidi reordering could make
26521 buffer positions of a row be 1,2,3,102,101,100, and if we
26522 want to highlight characters in [50..60), we don't want
26523 this row, even though [50..60) does intersect [1..103),
26524 the range of character positions given by the row's start
26525 and end positions. */
26526 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
26527 struct glyph
*e
= g
+ row
->used
[TEXT_AREA
];
26531 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
26532 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
26533 /* A glyph that comes from DISP_STRING is by
26534 definition to be highlighted. */
26535 || EQ (g
->object
, disp_string
))
26544 /* Find the END row. */
26546 /* If the last row is partially visible, start looking for END
26547 from that row, instead of starting from FIRST. */
26548 && !(row
->enabled_p
26549 && row
->y
< last_y
&& MATRIX_ROW_BOTTOM_Y (row
) > last_y
))
26551 for ( ; row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
; row
++)
26553 struct glyph_row
*next
= row
+ 1;
26554 ptrdiff_t next_start
= MATRIX_ROW_START_CHARPOS (next
);
26556 if (!next
->enabled_p
26557 || next
>= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
)
26558 /* The first row >= START whose range of displayed characters
26559 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
26560 is the row END + 1. */
26561 || (start_charpos
< next_start
26562 && end_charpos
< next_start
)
26563 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (next
)
26564 || (start_charpos
== MATRIX_ROW_END_CHARPOS (next
)
26565 && !next
->ends_at_zv_p
26566 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))
26567 && (end_charpos
> MATRIX_ROW_END_CHARPOS (next
)
26568 || (end_charpos
== MATRIX_ROW_END_CHARPOS (next
)
26569 && !next
->ends_at_zv_p
26570 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))))
26577 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
26578 but none of the characters it displays are in the range, it is
26580 struct glyph
*g
= next
->glyphs
[TEXT_AREA
];
26581 struct glyph
*s
= g
;
26582 struct glyph
*e
= g
+ next
->used
[TEXT_AREA
];
26586 if (((BUFFERP (g
->object
) || INTEGERP (g
->object
))
26587 && ((start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
26588 /* If the buffer position of the first glyph in
26589 the row is equal to END_CHARPOS, it means
26590 the last character to be highlighted is the
26591 newline of ROW, and we must consider NEXT as
26593 || (((!next
->reversed_p
&& g
== s
)
26594 || (next
->reversed_p
&& g
== e
- 1))
26595 && (g
->charpos
== end_charpos
26596 /* Special case for when NEXT is an
26597 empty line at ZV. */
26598 || (g
->charpos
== -1
26599 && !row
->ends_at_zv_p
26600 && next_start
== end_charpos
)))))
26601 /* A glyph that comes from DISP_STRING is by
26602 definition to be highlighted. */
26603 || EQ (g
->object
, disp_string
))
26612 /* The first row that ends at ZV must be the last to be
26614 else if (next
->ends_at_zv_p
)
26623 /* This function sets the mouse_face_* elements of HLINFO, assuming
26624 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
26625 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
26626 for the overlay or run of text properties specifying the mouse
26627 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
26628 before-string and after-string that must also be highlighted.
26629 DISP_STRING, if non-nil, is a display string that may cover some
26630 or all of the highlighted text. */
26633 mouse_face_from_buffer_pos (Lisp_Object window
,
26634 Mouse_HLInfo
*hlinfo
,
26635 ptrdiff_t mouse_charpos
,
26636 ptrdiff_t start_charpos
,
26637 ptrdiff_t end_charpos
,
26638 Lisp_Object before_string
,
26639 Lisp_Object after_string
,
26640 Lisp_Object disp_string
)
26642 struct window
*w
= XWINDOW (window
);
26643 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26644 struct glyph_row
*r1
, *r2
;
26645 struct glyph
*glyph
, *end
;
26646 ptrdiff_t ignore
, pos
;
26649 eassert (NILP (disp_string
) || STRINGP (disp_string
));
26650 eassert (NILP (before_string
) || STRINGP (before_string
));
26651 eassert (NILP (after_string
) || STRINGP (after_string
));
26653 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
26654 rows_from_pos_range (w
, start_charpos
, end_charpos
, disp_string
, &r1
, &r2
);
26656 r1
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26657 /* If the before-string or display-string contains newlines,
26658 rows_from_pos_range skips to its last row. Move back. */
26659 if (!NILP (before_string
) || !NILP (disp_string
))
26661 struct glyph_row
*prev
;
26662 while ((prev
= r1
- 1, prev
>= first
)
26663 && MATRIX_ROW_END_CHARPOS (prev
) == start_charpos
26664 && prev
->used
[TEXT_AREA
] > 0)
26666 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
26667 glyph
= beg
+ prev
->used
[TEXT_AREA
];
26668 while (--glyph
>= beg
&& INTEGERP (glyph
->object
));
26670 || !(EQ (glyph
->object
, before_string
)
26671 || EQ (glyph
->object
, disp_string
)))
26678 r2
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26679 hlinfo
->mouse_face_past_end
= 1;
26681 else if (!NILP (after_string
))
26683 /* If the after-string has newlines, advance to its last row. */
26684 struct glyph_row
*next
;
26685 struct glyph_row
*last
26686 = MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
26688 for (next
= r2
+ 1;
26690 && next
->used
[TEXT_AREA
] > 0
26691 && EQ (next
->glyphs
[TEXT_AREA
]->object
, after_string
);
26695 /* The rest of the display engine assumes that mouse_face_beg_row is
26696 either above mouse_face_end_row or identical to it. But with
26697 bidi-reordered continued lines, the row for START_CHARPOS could
26698 be below the row for END_CHARPOS. If so, swap the rows and store
26699 them in correct order. */
26702 struct glyph_row
*tem
= r2
;
26708 hlinfo
->mouse_face_beg_y
= r1
->y
;
26709 hlinfo
->mouse_face_beg_row
= MATRIX_ROW_VPOS (r1
, w
->current_matrix
);
26710 hlinfo
->mouse_face_end_y
= r2
->y
;
26711 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r2
, w
->current_matrix
);
26713 /* For a bidi-reordered row, the positions of BEFORE_STRING,
26714 AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
26715 could be anywhere in the row and in any order. The strategy
26716 below is to find the leftmost and the rightmost glyph that
26717 belongs to either of these 3 strings, or whose position is
26718 between START_CHARPOS and END_CHARPOS, and highlight all the
26719 glyphs between those two. This may cover more than just the text
26720 between START_CHARPOS and END_CHARPOS if the range of characters
26721 strides the bidi level boundary, e.g. if the beginning is in R2L
26722 text while the end is in L2R text or vice versa. */
26723 if (!r1
->reversed_p
)
26725 /* This row is in a left to right paragraph. Scan it left to
26727 glyph
= r1
->glyphs
[TEXT_AREA
];
26728 end
= glyph
+ r1
->used
[TEXT_AREA
];
26731 /* Skip truncation glyphs at the start of the glyph row. */
26732 if (r1
->displays_text_p
)
26734 && INTEGERP (glyph
->object
)
26735 && glyph
->charpos
< 0;
26737 x
+= glyph
->pixel_width
;
26739 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
26740 or DISP_STRING, and the first glyph from buffer whose
26741 position is between START_CHARPOS and END_CHARPOS. */
26743 && !INTEGERP (glyph
->object
)
26744 && !EQ (glyph
->object
, disp_string
)
26745 && !(BUFFERP (glyph
->object
)
26746 && (glyph
->charpos
>= start_charpos
26747 && glyph
->charpos
< end_charpos
));
26750 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26751 are present at buffer positions between START_CHARPOS and
26752 END_CHARPOS, or if they come from an overlay. */
26753 if (EQ (glyph
->object
, before_string
))
26755 pos
= string_buffer_position (before_string
,
26757 /* If pos == 0, it means before_string came from an
26758 overlay, not from a buffer position. */
26759 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26762 else if (EQ (glyph
->object
, after_string
))
26764 pos
= string_buffer_position (after_string
, end_charpos
);
26765 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26768 x
+= glyph
->pixel_width
;
26770 hlinfo
->mouse_face_beg_x
= x
;
26771 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
26775 /* This row is in a right to left paragraph. Scan it right to
26779 end
= r1
->glyphs
[TEXT_AREA
] - 1;
26780 glyph
= end
+ r1
->used
[TEXT_AREA
];
26782 /* Skip truncation glyphs at the start of the glyph row. */
26783 if (r1
->displays_text_p
)
26785 && INTEGERP (glyph
->object
)
26786 && glyph
->charpos
< 0;
26790 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
26791 or DISP_STRING, and the first glyph from buffer whose
26792 position is between START_CHARPOS and END_CHARPOS. */
26794 && !INTEGERP (glyph
->object
)
26795 && !EQ (glyph
->object
, disp_string
)
26796 && !(BUFFERP (glyph
->object
)
26797 && (glyph
->charpos
>= start_charpos
26798 && glyph
->charpos
< end_charpos
));
26801 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26802 are present at buffer positions between START_CHARPOS and
26803 END_CHARPOS, or if they come from an overlay. */
26804 if (EQ (glyph
->object
, before_string
))
26806 pos
= string_buffer_position (before_string
, start_charpos
);
26807 /* If pos == 0, it means before_string came from an
26808 overlay, not from a buffer position. */
26809 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26812 else if (EQ (glyph
->object
, after_string
))
26814 pos
= string_buffer_position (after_string
, end_charpos
);
26815 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26820 glyph
++; /* first glyph to the right of the highlighted area */
26821 for (g
= r1
->glyphs
[TEXT_AREA
], x
= r1
->x
; g
< glyph
; g
++)
26822 x
+= g
->pixel_width
;
26823 hlinfo
->mouse_face_beg_x
= x
;
26824 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
26827 /* If the highlight ends in a different row, compute GLYPH and END
26828 for the end row. Otherwise, reuse the values computed above for
26829 the row where the highlight begins. */
26832 if (!r2
->reversed_p
)
26834 glyph
= r2
->glyphs
[TEXT_AREA
];
26835 end
= glyph
+ r2
->used
[TEXT_AREA
];
26840 end
= r2
->glyphs
[TEXT_AREA
] - 1;
26841 glyph
= end
+ r2
->used
[TEXT_AREA
];
26845 if (!r2
->reversed_p
)
26847 /* Skip truncation and continuation glyphs near the end of the
26848 row, and also blanks and stretch glyphs inserted by
26849 extend_face_to_end_of_line. */
26851 && INTEGERP ((end
- 1)->object
))
26853 /* Scan the rest of the glyph row from the end, looking for the
26854 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26855 DISP_STRING, or whose position is between START_CHARPOS
26859 && !INTEGERP (end
->object
)
26860 && !EQ (end
->object
, disp_string
)
26861 && !(BUFFERP (end
->object
)
26862 && (end
->charpos
>= start_charpos
26863 && end
->charpos
< end_charpos
));
26866 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26867 are present at buffer positions between START_CHARPOS and
26868 END_CHARPOS, or if they come from an overlay. */
26869 if (EQ (end
->object
, before_string
))
26871 pos
= string_buffer_position (before_string
, start_charpos
);
26872 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26875 else if (EQ (end
->object
, after_string
))
26877 pos
= string_buffer_position (after_string
, end_charpos
);
26878 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26882 /* Find the X coordinate of the last glyph to be highlighted. */
26883 for (; glyph
<= end
; ++glyph
)
26884 x
+= glyph
->pixel_width
;
26886 hlinfo
->mouse_face_end_x
= x
;
26887 hlinfo
->mouse_face_end_col
= glyph
- r2
->glyphs
[TEXT_AREA
];
26891 /* Skip truncation and continuation glyphs near the end of the
26892 row, and also blanks and stretch glyphs inserted by
26893 extend_face_to_end_of_line. */
26897 && INTEGERP (end
->object
))
26899 x
+= end
->pixel_width
;
26902 /* Scan the rest of the glyph row from the end, looking for the
26903 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
26904 DISP_STRING, or whose position is between START_CHARPOS
26908 && !INTEGERP (end
->object
)
26909 && !EQ (end
->object
, disp_string
)
26910 && !(BUFFERP (end
->object
)
26911 && (end
->charpos
>= start_charpos
26912 && end
->charpos
< end_charpos
));
26915 /* BEFORE_STRING or AFTER_STRING are only relevant if they
26916 are present at buffer positions between START_CHARPOS and
26917 END_CHARPOS, or if they come from an overlay. */
26918 if (EQ (end
->object
, before_string
))
26920 pos
= string_buffer_position (before_string
, start_charpos
);
26921 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26924 else if (EQ (end
->object
, after_string
))
26926 pos
= string_buffer_position (after_string
, end_charpos
);
26927 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
26930 x
+= end
->pixel_width
;
26932 /* If we exited the above loop because we arrived at the last
26933 glyph of the row, and its buffer position is still not in
26934 range, it means the last character in range is the preceding
26935 newline. Bump the end column and x values to get past the
26938 && BUFFERP (end
->object
)
26939 && (end
->charpos
< start_charpos
26940 || end
->charpos
>= end_charpos
))
26942 x
+= end
->pixel_width
;
26945 hlinfo
->mouse_face_end_x
= x
;
26946 hlinfo
->mouse_face_end_col
= end
- r2
->glyphs
[TEXT_AREA
];
26949 hlinfo
->mouse_face_window
= window
;
26950 hlinfo
->mouse_face_face_id
26951 = face_at_buffer_position (w
, mouse_charpos
, 0, 0, &ignore
,
26953 !hlinfo
->mouse_face_hidden
, -1);
26954 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
26957 /* The following function is not used anymore (replaced with
26958 mouse_face_from_string_pos), but I leave it here for the time
26959 being, in case someone would. */
26961 #if 0 /* not used */
26963 /* Find the position of the glyph for position POS in OBJECT in
26964 window W's current matrix, and return in *X, *Y the pixel
26965 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
26967 RIGHT_P non-zero means return the position of the right edge of the
26968 glyph, RIGHT_P zero means return the left edge position.
26970 If no glyph for POS exists in the matrix, return the position of
26971 the glyph with the next smaller position that is in the matrix, if
26972 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
26973 exists in the matrix, return the position of the glyph with the
26974 next larger position in OBJECT.
26976 Value is non-zero if a glyph was found. */
26979 fast_find_string_pos (struct window
*w
, ptrdiff_t pos
, Lisp_Object object
,
26980 int *hpos
, int *vpos
, int *x
, int *y
, int right_p
)
26982 int yb
= window_text_bottom_y (w
);
26983 struct glyph_row
*r
;
26984 struct glyph
*best_glyph
= NULL
;
26985 struct glyph_row
*best_row
= NULL
;
26988 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
26989 r
->enabled_p
&& r
->y
< yb
;
26992 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
26993 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
26996 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
26997 if (EQ (g
->object
, object
))
26999 if (g
->charpos
== pos
)
27006 else if (best_glyph
== NULL
27007 || ((eabs (g
->charpos
- pos
)
27008 < eabs (best_glyph
->charpos
- pos
))
27011 : g
->charpos
> pos
)))
27025 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
27029 *x
+= best_glyph
->pixel_width
;
27034 *vpos
= best_row
- w
->current_matrix
->rows
;
27037 return best_glyph
!= NULL
;
27039 #endif /* not used */
27041 /* Find the positions of the first and the last glyphs in window W's
27042 current matrix that occlude positions [STARTPOS..ENDPOS] in OBJECT
27043 (assumed to be a string), and return in HLINFO's mouse_face_*
27044 members the pixel and column/row coordinates of those glyphs. */
27047 mouse_face_from_string_pos (struct window
*w
, Mouse_HLInfo
*hlinfo
,
27048 Lisp_Object object
,
27049 ptrdiff_t startpos
, ptrdiff_t endpos
)
27051 int yb
= window_text_bottom_y (w
);
27052 struct glyph_row
*r
;
27053 struct glyph
*g
, *e
;
27057 /* Find the glyph row with at least one position in the range
27058 [STARTPOS..ENDPOS], and the first glyph in that row whose
27059 position belongs to that range. */
27060 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
27061 r
->enabled_p
&& r
->y
< yb
;
27064 if (!r
->reversed_p
)
27066 g
= r
->glyphs
[TEXT_AREA
];
27067 e
= g
+ r
->used
[TEXT_AREA
];
27068 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
27069 if (EQ (g
->object
, object
)
27070 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
27072 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
27073 hlinfo
->mouse_face_beg_y
= r
->y
;
27074 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
27075 hlinfo
->mouse_face_beg_x
= gx
;
27084 e
= r
->glyphs
[TEXT_AREA
];
27085 g
= e
+ r
->used
[TEXT_AREA
];
27086 for ( ; g
> e
; --g
)
27087 if (EQ ((g
-1)->object
, object
)
27088 && startpos
<= (g
-1)->charpos
&& (g
-1)->charpos
<= endpos
)
27090 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
27091 hlinfo
->mouse_face_beg_y
= r
->y
;
27092 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
27093 for (gx
= r
->x
, g1
= r
->glyphs
[TEXT_AREA
]; g1
< g
; ++g1
)
27094 gx
+= g1
->pixel_width
;
27095 hlinfo
->mouse_face_beg_x
= gx
;
27107 /* Starting with the next row, look for the first row which does NOT
27108 include any glyphs whose positions are in the range. */
27109 for (++r
; r
->enabled_p
&& r
->y
< yb
; ++r
)
27111 g
= r
->glyphs
[TEXT_AREA
];
27112 e
= g
+ r
->used
[TEXT_AREA
];
27114 for ( ; g
< e
; ++g
)
27115 if (EQ (g
->object
, object
)
27116 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
27125 /* The highlighted region ends on the previous row. */
27128 /* Set the end row and its vertical pixel coordinate. */
27129 hlinfo
->mouse_face_end_row
= r
- w
->current_matrix
->rows
;
27130 hlinfo
->mouse_face_end_y
= r
->y
;
27132 /* Compute and set the end column and the end column's horizontal
27133 pixel coordinate. */
27134 if (!r
->reversed_p
)
27136 g
= r
->glyphs
[TEXT_AREA
];
27137 e
= g
+ r
->used
[TEXT_AREA
];
27138 for ( ; e
> g
; --e
)
27139 if (EQ ((e
-1)->object
, object
)
27140 && startpos
<= (e
-1)->charpos
&& (e
-1)->charpos
<= endpos
)
27142 hlinfo
->mouse_face_end_col
= e
- g
;
27144 for (gx
= r
->x
; g
< e
; ++g
)
27145 gx
+= g
->pixel_width
;
27146 hlinfo
->mouse_face_end_x
= gx
;
27150 e
= r
->glyphs
[TEXT_AREA
];
27151 g
= e
+ r
->used
[TEXT_AREA
];
27152 for (gx
= r
->x
; e
< g
; ++e
)
27154 if (EQ (e
->object
, object
)
27155 && startpos
<= e
->charpos
&& e
->charpos
<= endpos
)
27157 gx
+= e
->pixel_width
;
27159 hlinfo
->mouse_face_end_col
= e
- r
->glyphs
[TEXT_AREA
];
27160 hlinfo
->mouse_face_end_x
= gx
;
27164 #ifdef HAVE_WINDOW_SYSTEM
27166 /* See if position X, Y is within a hot-spot of an image. */
27169 on_hot_spot_p (Lisp_Object hot_spot
, int x
, int y
)
27171 if (!CONSP (hot_spot
))
27174 if (EQ (XCAR (hot_spot
), Qrect
))
27176 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
27177 Lisp_Object rect
= XCDR (hot_spot
);
27181 if (!CONSP (XCAR (rect
)))
27183 if (!CONSP (XCDR (rect
)))
27185 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
27187 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
27189 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
27191 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
27195 else if (EQ (XCAR (hot_spot
), Qcircle
))
27197 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
27198 Lisp_Object circ
= XCDR (hot_spot
);
27199 Lisp_Object lr
, lx0
, ly0
;
27201 && CONSP (XCAR (circ
))
27202 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
27203 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
27204 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
27206 double r
= XFLOATINT (lr
);
27207 double dx
= XINT (lx0
) - x
;
27208 double dy
= XINT (ly0
) - y
;
27209 return (dx
* dx
+ dy
* dy
<= r
* r
);
27212 else if (EQ (XCAR (hot_spot
), Qpoly
))
27214 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
27215 if (VECTORP (XCDR (hot_spot
)))
27217 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
27218 Lisp_Object
*poly
= v
->contents
;
27219 ptrdiff_t n
= v
->header
.size
;
27222 Lisp_Object lx
, ly
;
27225 /* Need an even number of coordinates, and at least 3 edges. */
27226 if (n
< 6 || n
& 1)
27229 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
27230 If count is odd, we are inside polygon. Pixels on edges
27231 may or may not be included depending on actual geometry of the
27233 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
27234 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
27236 x0
= XINT (lx
), y0
= XINT (ly
);
27237 for (i
= 0; i
< n
; i
+= 2)
27239 int x1
= x0
, y1
= y0
;
27240 if ((lx
= poly
[i
], !INTEGERP (lx
))
27241 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
27243 x0
= XINT (lx
), y0
= XINT (ly
);
27245 /* Does this segment cross the X line? */
27253 if (y
> y0
&& y
> y1
)
27255 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
27265 find_hot_spot (Lisp_Object map
, int x
, int y
)
27267 while (CONSP (map
))
27269 if (CONSP (XCAR (map
))
27270 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
27278 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
27280 doc
: /* Lookup in image map MAP coordinates X and Y.
27281 An image map is an alist where each element has the format (AREA ID PLIST).
27282 An AREA is specified as either a rectangle, a circle, or a polygon:
27283 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
27284 pixel coordinates of the upper left and bottom right corners.
27285 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
27286 and the radius of the circle; r may be a float or integer.
27287 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
27288 vector describes one corner in the polygon.
27289 Returns the alist element for the first matching AREA in MAP. */)
27290 (Lisp_Object map
, Lisp_Object x
, Lisp_Object y
)
27298 return find_hot_spot (map
,
27299 clip_to_bounds (INT_MIN
, XINT (x
), INT_MAX
),
27300 clip_to_bounds (INT_MIN
, XINT (y
), INT_MAX
));
27304 /* Display frame CURSOR, optionally using shape defined by POINTER. */
27306 define_frame_cursor1 (struct frame
*f
, Cursor cursor
, Lisp_Object pointer
)
27308 /* Do not change cursor shape while dragging mouse. */
27309 if (!NILP (do_mouse_tracking
))
27312 if (!NILP (pointer
))
27314 if (EQ (pointer
, Qarrow
))
27315 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27316 else if (EQ (pointer
, Qhand
))
27317 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
27318 else if (EQ (pointer
, Qtext
))
27319 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
27320 else if (EQ (pointer
, intern ("hdrag")))
27321 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
27322 #ifdef HAVE_X_WINDOWS
27323 else if (EQ (pointer
, intern ("vdrag")))
27324 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
27326 else if (EQ (pointer
, intern ("hourglass")))
27327 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
27328 else if (EQ (pointer
, Qmodeline
))
27329 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
27331 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27334 if (cursor
!= No_Cursor
)
27335 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
27338 #endif /* HAVE_WINDOW_SYSTEM */
27340 /* Take proper action when mouse has moved to the mode or header line
27341 or marginal area AREA of window W, x-position X and y-position Y.
27342 X is relative to the start of the text display area of W, so the
27343 width of bitmap areas and scroll bars must be subtracted to get a
27344 position relative to the start of the mode line. */
27347 note_mode_line_or_margin_highlight (Lisp_Object window
, int x
, int y
,
27348 enum window_part area
)
27350 struct window
*w
= XWINDOW (window
);
27351 struct frame
*f
= XFRAME (w
->frame
);
27352 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27353 #ifdef HAVE_WINDOW_SYSTEM
27354 Display_Info
*dpyinfo
;
27356 Cursor cursor
= No_Cursor
;
27357 Lisp_Object pointer
= Qnil
;
27358 int dx
, dy
, width
, height
;
27360 Lisp_Object string
, object
= Qnil
;
27361 Lisp_Object pos
IF_LINT (= Qnil
), help
;
27363 Lisp_Object mouse_face
;
27364 int original_x_pixel
= x
;
27365 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
27366 struct glyph_row
*row
IF_LINT (= 0);
27368 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
27373 /* Kludge alert: mode_line_string takes X/Y in pixels, but
27374 returns them in row/column units! */
27375 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
27376 &object
, &dx
, &dy
, &width
, &height
);
27378 row
= (area
== ON_MODE_LINE
27379 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
27380 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
27382 /* Find the glyph under the mouse pointer. */
27383 if (row
->mode_line_p
&& row
->enabled_p
)
27385 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
27386 end
= glyph
+ row
->used
[TEXT_AREA
];
27388 for (x0
= original_x_pixel
;
27389 glyph
< end
&& x0
>= glyph
->pixel_width
;
27391 x0
-= glyph
->pixel_width
;
27399 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
27400 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
27401 returns them in row/column units! */
27402 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
27403 &object
, &dx
, &dy
, &width
, &height
);
27408 #ifdef HAVE_WINDOW_SYSTEM
27409 if (IMAGEP (object
))
27411 Lisp_Object image_map
, hotspot
;
27412 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
27414 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
27416 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
27420 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
27421 If so, we could look for mouse-enter, mouse-leave
27422 properties in PLIST (and do something...). */
27423 hotspot
= XCDR (hotspot
);
27424 if (CONSP (hotspot
)
27425 && (plist
= XCAR (hotspot
), CONSP (plist
)))
27427 pointer
= Fplist_get (plist
, Qpointer
);
27428 if (NILP (pointer
))
27430 help
= Fplist_get (plist
, Qhelp_echo
);
27433 help_echo_string
= help
;
27434 XSETWINDOW (help_echo_window
, w
);
27435 help_echo_object
= w
->buffer
;
27436 help_echo_pos
= charpos
;
27440 if (NILP (pointer
))
27441 pointer
= Fplist_get (XCDR (object
), QCpointer
);
27443 #endif /* HAVE_WINDOW_SYSTEM */
27445 if (STRINGP (string
))
27446 pos
= make_number (charpos
);
27448 /* Set the help text and mouse pointer. If the mouse is on a part
27449 of the mode line without any text (e.g. past the right edge of
27450 the mode line text), use the default help text and pointer. */
27451 if (STRINGP (string
) || area
== ON_MODE_LINE
)
27453 /* Arrange to display the help by setting the global variables
27454 help_echo_string, help_echo_object, and help_echo_pos. */
27457 if (STRINGP (string
))
27458 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
27462 help_echo_string
= help
;
27463 XSETWINDOW (help_echo_window
, w
);
27464 help_echo_object
= string
;
27465 help_echo_pos
= charpos
;
27467 else if (area
== ON_MODE_LINE
)
27469 Lisp_Object default_help
27470 = buffer_local_value_1 (Qmode_line_default_help_echo
,
27473 if (STRINGP (default_help
))
27475 help_echo_string
= default_help
;
27476 XSETWINDOW (help_echo_window
, w
);
27477 help_echo_object
= Qnil
;
27478 help_echo_pos
= -1;
27483 #ifdef HAVE_WINDOW_SYSTEM
27484 /* Change the mouse pointer according to what is under it. */
27485 if (FRAME_WINDOW_P (f
))
27487 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
27488 if (STRINGP (string
))
27490 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27492 if (NILP (pointer
))
27493 pointer
= Fget_text_property (pos
, Qpointer
, string
);
27495 /* Change the mouse pointer according to what is under X/Y. */
27497 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
27500 map
= Fget_text_property (pos
, Qlocal_map
, string
);
27501 if (!KEYMAPP (map
))
27502 map
= Fget_text_property (pos
, Qkeymap
, string
);
27503 if (!KEYMAPP (map
))
27504 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
27508 /* Default mode-line pointer. */
27509 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
27514 /* Change the mouse face according to what is under X/Y. */
27515 if (STRINGP (string
))
27517 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
27518 if (!NILP (mouse_face
)
27519 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
27524 struct glyph
* tmp_glyph
;
27528 int total_pixel_width
;
27529 ptrdiff_t begpos
, endpos
, ignore
;
27533 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
27534 Qmouse_face
, string
, Qnil
);
27540 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
27542 endpos
= SCHARS (string
);
27546 /* Calculate the glyph position GPOS of GLYPH in the
27547 displayed string, relative to the beginning of the
27548 highlighted part of the string.
27550 Note: GPOS is different from CHARPOS. CHARPOS is the
27551 position of GLYPH in the internal string object. A mode
27552 line string format has structures which are converted to
27553 a flattened string by the Emacs Lisp interpreter. The
27554 internal string is an element of those structures. The
27555 displayed string is the flattened string. */
27556 tmp_glyph
= row_start_glyph
;
27557 while (tmp_glyph
< glyph
27558 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
27559 && begpos
<= tmp_glyph
->charpos
27560 && tmp_glyph
->charpos
< endpos
)))
27562 gpos
= glyph
- tmp_glyph
;
27564 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
27565 the highlighted part of the displayed string to which
27566 GLYPH belongs. Note: GSEQ_LENGTH is different from
27567 SCHARS (STRING), because the latter returns the length of
27568 the internal string. */
27569 for (tmp_glyph
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
27571 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
27572 && begpos
<= tmp_glyph
->charpos
27573 && tmp_glyph
->charpos
< endpos
));
27576 gseq_length
= gpos
+ (tmp_glyph
- glyph
) + 1;
27578 /* Calculate the total pixel width of all the glyphs between
27579 the beginning of the highlighted area and GLYPH. */
27580 total_pixel_width
= 0;
27581 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
27582 total_pixel_width
+= tmp_glyph
->pixel_width
;
27584 /* Pre calculation of re-rendering position. Note: X is in
27585 column units here, after the call to mode_line_string or
27586 marginal_area_string. */
27588 vpos
= (area
== ON_MODE_LINE
27589 ? (w
->current_matrix
)->nrows
- 1
27592 /* If GLYPH's position is included in the region that is
27593 already drawn in mouse face, we have nothing to do. */
27594 if ( EQ (window
, hlinfo
->mouse_face_window
)
27595 && (!row
->reversed_p
27596 ? (hlinfo
->mouse_face_beg_col
<= hpos
27597 && hpos
< hlinfo
->mouse_face_end_col
)
27598 /* In R2L rows we swap BEG and END, see below. */
27599 : (hlinfo
->mouse_face_end_col
<= hpos
27600 && hpos
< hlinfo
->mouse_face_beg_col
))
27601 && hlinfo
->mouse_face_beg_row
== vpos
)
27604 if (clear_mouse_face (hlinfo
))
27605 cursor
= No_Cursor
;
27607 if (!row
->reversed_p
)
27609 hlinfo
->mouse_face_beg_col
= hpos
;
27610 hlinfo
->mouse_face_beg_x
= original_x_pixel
27611 - (total_pixel_width
+ dx
);
27612 hlinfo
->mouse_face_end_col
= hpos
+ gseq_length
;
27613 hlinfo
->mouse_face_end_x
= 0;
27617 /* In R2L rows, show_mouse_face expects BEG and END
27618 coordinates to be swapped. */
27619 hlinfo
->mouse_face_end_col
= hpos
;
27620 hlinfo
->mouse_face_end_x
= original_x_pixel
27621 - (total_pixel_width
+ dx
);
27622 hlinfo
->mouse_face_beg_col
= hpos
+ gseq_length
;
27623 hlinfo
->mouse_face_beg_x
= 0;
27626 hlinfo
->mouse_face_beg_row
= vpos
;
27627 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_beg_row
;
27628 hlinfo
->mouse_face_beg_y
= 0;
27629 hlinfo
->mouse_face_end_y
= 0;
27630 hlinfo
->mouse_face_past_end
= 0;
27631 hlinfo
->mouse_face_window
= window
;
27633 hlinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
27639 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
27641 if (NILP (pointer
))
27644 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
27645 clear_mouse_face (hlinfo
);
27647 #ifdef HAVE_WINDOW_SYSTEM
27648 if (FRAME_WINDOW_P (f
))
27649 define_frame_cursor1 (f
, cursor
, pointer
);
27655 Take proper action when the mouse has moved to position X, Y on
27656 frame F as regards highlighting characters that have mouse-face
27657 properties. Also de-highlighting chars where the mouse was before.
27658 X and Y can be negative or out of range. */
27661 note_mouse_highlight (struct frame
*f
, int x
, int y
)
27663 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27664 enum window_part part
= ON_NOTHING
;
27665 Lisp_Object window
;
27667 Cursor cursor
= No_Cursor
;
27668 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
27671 /* When a menu is active, don't highlight because this looks odd. */
27672 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
27673 if (popup_activated ())
27677 if (NILP (Vmouse_highlight
)
27678 || !f
->glyphs_initialized_p
27679 || f
->pointer_invisible
)
27682 hlinfo
->mouse_face_mouse_x
= x
;
27683 hlinfo
->mouse_face_mouse_y
= y
;
27684 hlinfo
->mouse_face_mouse_frame
= f
;
27686 if (hlinfo
->mouse_face_defer
)
27689 /* Which window is that in? */
27690 window
= window_from_coordinates (f
, x
, y
, &part
, 1);
27692 /* If displaying active text in another window, clear that. */
27693 if (! EQ (window
, hlinfo
->mouse_face_window
)
27694 /* Also clear if we move out of text area in same window. */
27695 || (!NILP (hlinfo
->mouse_face_window
)
27698 && part
!= ON_MODE_LINE
27699 && part
!= ON_HEADER_LINE
))
27700 clear_mouse_face (hlinfo
);
27702 /* Not on a window -> return. */
27703 if (!WINDOWP (window
))
27706 /* Reset help_echo_string. It will get recomputed below. */
27707 help_echo_string
= Qnil
;
27709 /* Convert to window-relative pixel coordinates. */
27710 w
= XWINDOW (window
);
27711 frame_to_window_pixel_xy (w
, &x
, &y
);
27713 #ifdef HAVE_WINDOW_SYSTEM
27714 /* Handle tool-bar window differently since it doesn't display a
27716 if (EQ (window
, f
->tool_bar_window
))
27718 note_tool_bar_highlight (f
, x
, y
);
27723 /* Mouse is on the mode, header line or margin? */
27724 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
27725 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
27727 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
27731 #ifdef HAVE_WINDOW_SYSTEM
27732 if (part
== ON_VERTICAL_BORDER
)
27734 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
27735 help_echo_string
= build_string ("drag-mouse-1: resize");
27737 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
27738 || part
== ON_SCROLL_BAR
)
27739 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27741 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
27744 /* Are we in a window whose display is up to date?
27745 And verify the buffer's text has not changed. */
27746 b
= XBUFFER (w
->buffer
);
27747 if (part
== ON_TEXT
27748 && EQ (w
->window_end_valid
, w
->buffer
)
27749 && w
->last_modified
== BUF_MODIFF (b
)
27750 && w
->last_overlay_modified
== BUF_OVERLAY_MODIFF (b
))
27752 int hpos
, vpos
, dx
, dy
, area
= LAST_AREA
;
27754 struct glyph
*glyph
;
27755 Lisp_Object object
;
27756 Lisp_Object mouse_face
= Qnil
, position
;
27757 Lisp_Object
*overlay_vec
= NULL
;
27758 ptrdiff_t i
, noverlays
;
27759 struct buffer
*obuf
;
27760 ptrdiff_t obegv
, ozv
;
27763 /* Find the glyph under X/Y. */
27764 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
27766 #ifdef HAVE_WINDOW_SYSTEM
27767 /* Look for :pointer property on image. */
27768 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
27770 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
27771 if (img
!= NULL
&& IMAGEP (img
->spec
))
27773 Lisp_Object image_map
, hotspot
;
27774 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
27776 && (hotspot
= find_hot_spot (image_map
,
27777 glyph
->slice
.img
.x
+ dx
,
27778 glyph
->slice
.img
.y
+ dy
),
27780 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
27784 /* Could check XCAR (hotspot) to see if we enter/leave
27786 If so, we could look for mouse-enter, mouse-leave
27787 properties in PLIST (and do something...). */
27788 hotspot
= XCDR (hotspot
);
27789 if (CONSP (hotspot
)
27790 && (plist
= XCAR (hotspot
), CONSP (plist
)))
27792 pointer
= Fplist_get (plist
, Qpointer
);
27793 if (NILP (pointer
))
27795 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
27796 if (!NILP (help_echo_string
))
27798 help_echo_window
= window
;
27799 help_echo_object
= glyph
->object
;
27800 help_echo_pos
= glyph
->charpos
;
27804 if (NILP (pointer
))
27805 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
27808 #endif /* HAVE_WINDOW_SYSTEM */
27810 /* Clear mouse face if X/Y not over text. */
27812 || area
!= TEXT_AREA
27813 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
27814 /* Glyph's OBJECT is an integer for glyphs inserted by the
27815 display engine for its internal purposes, like truncation
27816 and continuation glyphs and blanks beyond the end of
27817 line's text on text terminals. If we are over such a
27818 glyph, we are not over any text. */
27819 || INTEGERP (glyph
->object
)
27820 /* R2L rows have a stretch glyph at their front, which
27821 stands for no text, whereas L2R rows have no glyphs at
27822 all beyond the end of text. Treat such stretch glyphs
27823 like we do with NULL glyphs in L2R rows. */
27824 || (MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
27825 && glyph
== MATRIX_ROW (w
->current_matrix
, vpos
)->glyphs
[TEXT_AREA
]
27826 && glyph
->type
== STRETCH_GLYPH
27827 && glyph
->avoid_cursor_p
))
27829 if (clear_mouse_face (hlinfo
))
27830 cursor
= No_Cursor
;
27831 #ifdef HAVE_WINDOW_SYSTEM
27832 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
27834 if (area
!= TEXT_AREA
)
27835 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
27837 pointer
= Vvoid_text_area_pointer
;
27843 pos
= glyph
->charpos
;
27844 object
= glyph
->object
;
27845 if (!STRINGP (object
) && !BUFFERP (object
))
27848 /* If we get an out-of-range value, return now; avoid an error. */
27849 if (BUFFERP (object
) && pos
> BUF_Z (b
))
27852 /* Make the window's buffer temporarily current for
27853 overlays_at and compute_char_face. */
27854 obuf
= current_buffer
;
27855 current_buffer
= b
;
27861 /* Is this char mouse-active or does it have help-echo? */
27862 position
= make_number (pos
);
27864 if (BUFFERP (object
))
27866 /* Put all the overlays we want in a vector in overlay_vec. */
27867 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
27868 /* Sort overlays into increasing priority order. */
27869 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
27874 same_region
= coords_in_mouse_face_p (w
, hpos
, vpos
);
27877 cursor
= No_Cursor
;
27879 /* Check mouse-face highlighting. */
27881 /* If there exists an overlay with mouse-face overlapping
27882 the one we are currently highlighting, we have to
27883 check if we enter the overlapping overlay, and then
27884 highlight only that. */
27885 || (OVERLAYP (hlinfo
->mouse_face_overlay
)
27886 && mouse_face_overlay_overlaps (hlinfo
->mouse_face_overlay
)))
27888 /* Find the highest priority overlay with a mouse-face. */
27889 Lisp_Object overlay
= Qnil
;
27890 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
27892 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
27893 if (!NILP (mouse_face
))
27894 overlay
= overlay_vec
[i
];
27897 /* If we're highlighting the same overlay as before, there's
27898 no need to do that again. */
27899 if (!NILP (overlay
) && EQ (overlay
, hlinfo
->mouse_face_overlay
))
27900 goto check_help_echo
;
27901 hlinfo
->mouse_face_overlay
= overlay
;
27903 /* Clear the display of the old active region, if any. */
27904 if (clear_mouse_face (hlinfo
))
27905 cursor
= No_Cursor
;
27907 /* If no overlay applies, get a text property. */
27908 if (NILP (overlay
))
27909 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
27911 /* Next, compute the bounds of the mouse highlighting and
27913 if (!NILP (mouse_face
) && STRINGP (object
))
27915 /* The mouse-highlighting comes from a display string
27916 with a mouse-face. */
27920 s
= Fprevious_single_property_change
27921 (make_number (pos
+ 1), Qmouse_face
, object
, Qnil
);
27922 e
= Fnext_single_property_change
27923 (position
, Qmouse_face
, object
, Qnil
);
27925 s
= make_number (0);
27927 e
= make_number (SCHARS (object
) - 1);
27928 mouse_face_from_string_pos (w
, hlinfo
, object
,
27929 XINT (s
), XINT (e
));
27930 hlinfo
->mouse_face_past_end
= 0;
27931 hlinfo
->mouse_face_window
= window
;
27932 hlinfo
->mouse_face_face_id
27933 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
27934 glyph
->face_id
, 1);
27935 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
27936 cursor
= No_Cursor
;
27940 /* The mouse-highlighting, if any, comes from an overlay
27941 or text property in the buffer. */
27942 Lisp_Object buffer
IF_LINT (= Qnil
);
27943 Lisp_Object disp_string
IF_LINT (= Qnil
);
27945 if (STRINGP (object
))
27947 /* If we are on a display string with no mouse-face,
27948 check if the text under it has one. */
27949 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
27950 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
27951 pos
= string_buffer_position (object
, start
);
27954 mouse_face
= get_char_property_and_overlay
27955 (make_number (pos
), Qmouse_face
, w
->buffer
, &overlay
);
27956 buffer
= w
->buffer
;
27957 disp_string
= object
;
27963 disp_string
= Qnil
;
27966 if (!NILP (mouse_face
))
27968 Lisp_Object before
, after
;
27969 Lisp_Object before_string
, after_string
;
27970 /* To correctly find the limits of mouse highlight
27971 in a bidi-reordered buffer, we must not use the
27972 optimization of limiting the search in
27973 previous-single-property-change and
27974 next-single-property-change, because
27975 rows_from_pos_range needs the real start and end
27976 positions to DTRT in this case. That's because
27977 the first row visible in a window does not
27978 necessarily display the character whose position
27979 is the smallest. */
27981 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
27982 ? Fmarker_position (w
->start
)
27985 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
27986 ? make_number (BUF_Z (XBUFFER (buffer
))
27987 - XFASTINT (w
->window_end_pos
))
27990 if (NILP (overlay
))
27992 /* Handle the text property case. */
27993 before
= Fprevious_single_property_change
27994 (make_number (pos
+ 1), Qmouse_face
, buffer
, lim1
);
27995 after
= Fnext_single_property_change
27996 (make_number (pos
), Qmouse_face
, buffer
, lim2
);
27997 before_string
= after_string
= Qnil
;
28001 /* Handle the overlay case. */
28002 before
= Foverlay_start (overlay
);
28003 after
= Foverlay_end (overlay
);
28004 before_string
= Foverlay_get (overlay
, Qbefore_string
);
28005 after_string
= Foverlay_get (overlay
, Qafter_string
);
28007 if (!STRINGP (before_string
)) before_string
= Qnil
;
28008 if (!STRINGP (after_string
)) after_string
= Qnil
;
28011 mouse_face_from_buffer_pos (window
, hlinfo
, pos
,
28014 : XFASTINT (before
),
28016 ? BUF_Z (XBUFFER (buffer
))
28017 : XFASTINT (after
),
28018 before_string
, after_string
,
28020 cursor
= No_Cursor
;
28027 /* Look for a `help-echo' property. */
28028 if (NILP (help_echo_string
)) {
28029 Lisp_Object help
, overlay
;
28031 /* Check overlays first. */
28032 help
= overlay
= Qnil
;
28033 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
28035 overlay
= overlay_vec
[i
];
28036 help
= Foverlay_get (overlay
, Qhelp_echo
);
28041 help_echo_string
= help
;
28042 help_echo_window
= window
;
28043 help_echo_object
= overlay
;
28044 help_echo_pos
= pos
;
28048 Lisp_Object obj
= glyph
->object
;
28049 ptrdiff_t charpos
= glyph
->charpos
;
28051 /* Try text properties. */
28054 && charpos
< SCHARS (obj
))
28056 help
= Fget_text_property (make_number (charpos
),
28060 /* If the string itself doesn't specify a help-echo,
28061 see if the buffer text ``under'' it does. */
28062 struct glyph_row
*r
28063 = MATRIX_ROW (w
->current_matrix
, vpos
);
28064 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
28065 ptrdiff_t p
= string_buffer_position (obj
, start
);
28068 help
= Fget_char_property (make_number (p
),
28069 Qhelp_echo
, w
->buffer
);
28078 else if (BUFFERP (obj
)
28081 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
28086 help_echo_string
= help
;
28087 help_echo_window
= window
;
28088 help_echo_object
= obj
;
28089 help_echo_pos
= charpos
;
28094 #ifdef HAVE_WINDOW_SYSTEM
28095 /* Look for a `pointer' property. */
28096 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
28098 /* Check overlays first. */
28099 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
28100 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
28102 if (NILP (pointer
))
28104 Lisp_Object obj
= glyph
->object
;
28105 ptrdiff_t charpos
= glyph
->charpos
;
28107 /* Try text properties. */
28110 && charpos
< SCHARS (obj
))
28112 pointer
= Fget_text_property (make_number (charpos
),
28114 if (NILP (pointer
))
28116 /* If the string itself doesn't specify a pointer,
28117 see if the buffer text ``under'' it does. */
28118 struct glyph_row
*r
28119 = MATRIX_ROW (w
->current_matrix
, vpos
);
28120 ptrdiff_t start
= MATRIX_ROW_START_CHARPOS (r
);
28121 ptrdiff_t p
= string_buffer_position (obj
, start
);
28123 pointer
= Fget_char_property (make_number (p
),
28124 Qpointer
, w
->buffer
);
28127 else if (BUFFERP (obj
)
28130 pointer
= Fget_text_property (make_number (charpos
),
28134 #endif /* HAVE_WINDOW_SYSTEM */
28138 current_buffer
= obuf
;
28143 #ifdef HAVE_WINDOW_SYSTEM
28144 if (FRAME_WINDOW_P (f
))
28145 define_frame_cursor1 (f
, cursor
, pointer
);
28147 /* This is here to prevent a compiler error, about "label at end of
28148 compound statement". */
28155 Clear any mouse-face on window W. This function is part of the
28156 redisplay interface, and is called from try_window_id and similar
28157 functions to ensure the mouse-highlight is off. */
28160 x_clear_window_mouse_face (struct window
*w
)
28162 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
28163 Lisp_Object window
;
28166 XSETWINDOW (window
, w
);
28167 if (EQ (window
, hlinfo
->mouse_face_window
))
28168 clear_mouse_face (hlinfo
);
28174 Just discard the mouse face information for frame F, if any.
28175 This is used when the size of F is changed. */
28178 cancel_mouse_face (struct frame
*f
)
28180 Lisp_Object window
;
28181 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28183 window
= hlinfo
->mouse_face_window
;
28184 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
28186 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
28187 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
28188 hlinfo
->mouse_face_window
= Qnil
;
28194 /***********************************************************************
28196 ***********************************************************************/
28198 #ifdef HAVE_WINDOW_SYSTEM
28200 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
28201 which intersects rectangle R. R is in window-relative coordinates. */
28204 expose_area (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
,
28205 enum glyph_row_area area
)
28207 struct glyph
*first
= row
->glyphs
[area
];
28208 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
28209 struct glyph
*last
;
28210 int first_x
, start_x
, x
;
28212 if (area
== TEXT_AREA
&& row
->fill_line_p
)
28213 /* If row extends face to end of line write the whole line. */
28214 draw_glyphs (w
, 0, row
, area
,
28215 0, row
->used
[area
],
28216 DRAW_NORMAL_TEXT
, 0);
28219 /* Set START_X to the window-relative start position for drawing glyphs of
28220 AREA. The first glyph of the text area can be partially visible.
28221 The first glyphs of other areas cannot. */
28222 start_x
= window_box_left_offset (w
, area
);
28224 if (area
== TEXT_AREA
)
28227 /* Find the first glyph that must be redrawn. */
28229 && x
+ first
->pixel_width
< r
->x
)
28231 x
+= first
->pixel_width
;
28235 /* Find the last one. */
28239 && x
< r
->x
+ r
->width
)
28241 x
+= last
->pixel_width
;
28247 draw_glyphs (w
, first_x
- start_x
, row
, area
,
28248 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
28249 DRAW_NORMAL_TEXT
, 0);
28254 /* Redraw the parts of the glyph row ROW on window W intersecting
28255 rectangle R. R is in window-relative coordinates. Value is
28256 non-zero if mouse-face was overwritten. */
28259 expose_line (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
)
28261 eassert (row
->enabled_p
);
28263 if (row
->mode_line_p
|| w
->pseudo_window_p
)
28264 draw_glyphs (w
, 0, row
, TEXT_AREA
,
28265 0, row
->used
[TEXT_AREA
],
28266 DRAW_NORMAL_TEXT
, 0);
28269 if (row
->used
[LEFT_MARGIN_AREA
])
28270 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
28271 if (row
->used
[TEXT_AREA
])
28272 expose_area (w
, row
, r
, TEXT_AREA
);
28273 if (row
->used
[RIGHT_MARGIN_AREA
])
28274 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
28275 draw_row_fringe_bitmaps (w
, row
);
28278 return row
->mouse_face_p
;
28282 /* Redraw those parts of glyphs rows during expose event handling that
28283 overlap other rows. Redrawing of an exposed line writes over parts
28284 of lines overlapping that exposed line; this function fixes that.
28286 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
28287 row in W's current matrix that is exposed and overlaps other rows.
28288 LAST_OVERLAPPING_ROW is the last such row. */
28291 expose_overlaps (struct window
*w
,
28292 struct glyph_row
*first_overlapping_row
,
28293 struct glyph_row
*last_overlapping_row
,
28296 struct glyph_row
*row
;
28298 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
28299 if (row
->overlapping_p
)
28301 eassert (row
->enabled_p
&& !row
->mode_line_p
);
28304 if (row
->used
[LEFT_MARGIN_AREA
])
28305 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
28307 if (row
->used
[TEXT_AREA
])
28308 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
28310 if (row
->used
[RIGHT_MARGIN_AREA
])
28311 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
28317 /* Return non-zero if W's cursor intersects rectangle R. */
28320 phys_cursor_in_rect_p (struct window
*w
, XRectangle
*r
)
28322 XRectangle cr
, result
;
28323 struct glyph
*cursor_glyph
;
28324 struct glyph_row
*row
;
28326 if (w
->phys_cursor
.vpos
>= 0
28327 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
28328 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
28330 && row
->cursor_in_fringe_p
)
28332 /* Cursor is in the fringe. */
28333 cr
.x
= window_box_right_offset (w
,
28334 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
28335 ? RIGHT_MARGIN_AREA
28338 cr
.width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
28339 cr
.height
= row
->height
;
28340 return x_intersect_rectangles (&cr
, r
, &result
);
28343 cursor_glyph
= get_phys_cursor_glyph (w
);
28346 /* r is relative to W's box, but w->phys_cursor.x is relative
28347 to left edge of W's TEXT area. Adjust it. */
28348 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
28349 cr
.y
= w
->phys_cursor
.y
;
28350 cr
.width
= cursor_glyph
->pixel_width
;
28351 cr
.height
= w
->phys_cursor_height
;
28352 /* ++KFS: W32 version used W32-specific IntersectRect here, but
28353 I assume the effect is the same -- and this is portable. */
28354 return x_intersect_rectangles (&cr
, r
, &result
);
28356 /* If we don't understand the format, pretend we're not in the hot-spot. */
28362 Draw a vertical window border to the right of window W if W doesn't
28363 have vertical scroll bars. */
28366 x_draw_vertical_border (struct window
*w
)
28368 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
28370 /* We could do better, if we knew what type of scroll-bar the adjacent
28371 windows (on either side) have... But we don't :-(
28372 However, I think this works ok. ++KFS 2003-04-25 */
28374 /* Redraw borders between horizontally adjacent windows. Don't
28375 do it for frames with vertical scroll bars because either the
28376 right scroll bar of a window, or the left scroll bar of its
28377 neighbor will suffice as a border. */
28378 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w
->frame
)))
28381 if (!WINDOW_RIGHTMOST_P (w
)
28382 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
28384 int x0
, x1
, y0
, y1
;
28386 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
28389 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
28392 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
28394 else if (!WINDOW_LEFTMOST_P (w
)
28395 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
28397 int x0
, x1
, y0
, y1
;
28399 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
28402 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
28405 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
28410 /* Redraw the part of window W intersection rectangle FR. Pixel
28411 coordinates in FR are frame-relative. Call this function with
28412 input blocked. Value is non-zero if the exposure overwrites
28416 expose_window (struct window
*w
, XRectangle
*fr
)
28418 struct frame
*f
= XFRAME (w
->frame
);
28420 int mouse_face_overwritten_p
= 0;
28422 /* If window is not yet fully initialized, do nothing. This can
28423 happen when toolkit scroll bars are used and a window is split.
28424 Reconfiguring the scroll bar will generate an expose for a newly
28426 if (w
->current_matrix
== NULL
)
28429 /* When we're currently updating the window, display and current
28430 matrix usually don't agree. Arrange for a thorough display
28432 if (w
== updated_window
)
28434 SET_FRAME_GARBAGED (f
);
28438 /* Frame-relative pixel rectangle of W. */
28439 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
28440 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
28441 wr
.width
= WINDOW_TOTAL_WIDTH (w
);
28442 wr
.height
= WINDOW_TOTAL_HEIGHT (w
);
28444 if (x_intersect_rectangles (fr
, &wr
, &r
))
28446 int yb
= window_text_bottom_y (w
);
28447 struct glyph_row
*row
;
28448 int cursor_cleared_p
, phys_cursor_on_p
;
28449 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
28451 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
28452 r
.x
, r
.y
, r
.width
, r
.height
));
28454 /* Convert to window coordinates. */
28455 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
28456 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
28458 /* Turn off the cursor. */
28459 if (!w
->pseudo_window_p
28460 && phys_cursor_in_rect_p (w
, &r
))
28462 x_clear_cursor (w
);
28463 cursor_cleared_p
= 1;
28466 cursor_cleared_p
= 0;
28468 /* If the row containing the cursor extends face to end of line,
28469 then expose_area might overwrite the cursor outside the
28470 rectangle and thus notice_overwritten_cursor might clear
28471 w->phys_cursor_on_p. We remember the original value and
28472 check later if it is changed. */
28473 phys_cursor_on_p
= w
->phys_cursor_on_p
;
28475 /* Update lines intersecting rectangle R. */
28476 first_overlapping_row
= last_overlapping_row
= NULL
;
28477 for (row
= w
->current_matrix
->rows
;
28482 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
28484 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
28485 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
28486 || (r
.y
>= y0
&& r
.y
< y1
)
28487 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
28489 /* A header line may be overlapping, but there is no need
28490 to fix overlapping areas for them. KFS 2005-02-12 */
28491 if (row
->overlapping_p
&& !row
->mode_line_p
)
28493 if (first_overlapping_row
== NULL
)
28494 first_overlapping_row
= row
;
28495 last_overlapping_row
= row
;
28499 if (expose_line (w
, row
, &r
))
28500 mouse_face_overwritten_p
= 1;
28503 else if (row
->overlapping_p
)
28505 /* We must redraw a row overlapping the exposed area. */
28507 ? y0
+ row
->phys_height
> r
.y
28508 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
28510 if (first_overlapping_row
== NULL
)
28511 first_overlapping_row
= row
;
28512 last_overlapping_row
= row
;
28520 /* Display the mode line if there is one. */
28521 if (WINDOW_WANTS_MODELINE_P (w
)
28522 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
28524 && row
->y
< r
.y
+ r
.height
)
28526 if (expose_line (w
, row
, &r
))
28527 mouse_face_overwritten_p
= 1;
28530 if (!w
->pseudo_window_p
)
28532 /* Fix the display of overlapping rows. */
28533 if (first_overlapping_row
)
28534 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
28537 /* Draw border between windows. */
28538 x_draw_vertical_border (w
);
28540 /* Turn the cursor on again. */
28541 if (cursor_cleared_p
28542 || (phys_cursor_on_p
&& !w
->phys_cursor_on_p
))
28543 update_window_cursor (w
, 1);
28547 return mouse_face_overwritten_p
;
28552 /* Redraw (parts) of all windows in the window tree rooted at W that
28553 intersect R. R contains frame pixel coordinates. Value is
28554 non-zero if the exposure overwrites mouse-face. */
28557 expose_window_tree (struct window
*w
, XRectangle
*r
)
28559 struct frame
*f
= XFRAME (w
->frame
);
28560 int mouse_face_overwritten_p
= 0;
28562 while (w
&& !FRAME_GARBAGED_P (f
))
28564 if (!NILP (w
->hchild
))
28565 mouse_face_overwritten_p
28566 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
28567 else if (!NILP (w
->vchild
))
28568 mouse_face_overwritten_p
28569 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
28571 mouse_face_overwritten_p
|= expose_window (w
, r
);
28573 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
28576 return mouse_face_overwritten_p
;
28581 Redisplay an exposed area of frame F. X and Y are the upper-left
28582 corner of the exposed rectangle. W and H are width and height of
28583 the exposed area. All are pixel values. W or H zero means redraw
28584 the entire frame. */
28587 expose_frame (struct frame
*f
, int x
, int y
, int w
, int h
)
28590 int mouse_face_overwritten_p
= 0;
28592 TRACE ((stderr
, "expose_frame "));
28594 /* No need to redraw if frame will be redrawn soon. */
28595 if (FRAME_GARBAGED_P (f
))
28597 TRACE ((stderr
, " garbaged\n"));
28601 /* If basic faces haven't been realized yet, there is no point in
28602 trying to redraw anything. This can happen when we get an expose
28603 event while Emacs is starting, e.g. by moving another window. */
28604 if (FRAME_FACE_CACHE (f
) == NULL
28605 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
28607 TRACE ((stderr
, " no faces\n"));
28611 if (w
== 0 || h
== 0)
28614 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
28615 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
28625 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
28626 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
28628 if (WINDOWP (f
->tool_bar_window
))
28629 mouse_face_overwritten_p
28630 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
28632 #ifdef HAVE_X_WINDOWS
28634 #ifndef USE_X_TOOLKIT
28635 if (WINDOWP (f
->menu_bar_window
))
28636 mouse_face_overwritten_p
28637 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
28638 #endif /* not USE_X_TOOLKIT */
28642 /* Some window managers support a focus-follows-mouse style with
28643 delayed raising of frames. Imagine a partially obscured frame,
28644 and moving the mouse into partially obscured mouse-face on that
28645 frame. The visible part of the mouse-face will be highlighted,
28646 then the WM raises the obscured frame. With at least one WM, KDE
28647 2.1, Emacs is not getting any event for the raising of the frame
28648 (even tried with SubstructureRedirectMask), only Expose events.
28649 These expose events will draw text normally, i.e. not
28650 highlighted. Which means we must redo the highlight here.
28651 Subsume it under ``we love X''. --gerd 2001-08-15 */
28652 /* Included in Windows version because Windows most likely does not
28653 do the right thing if any third party tool offers
28654 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
28655 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
28657 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
28658 if (f
== hlinfo
->mouse_face_mouse_frame
)
28660 int mouse_x
= hlinfo
->mouse_face_mouse_x
;
28661 int mouse_y
= hlinfo
->mouse_face_mouse_y
;
28662 clear_mouse_face (hlinfo
);
28663 note_mouse_highlight (f
, mouse_x
, mouse_y
);
28670 Determine the intersection of two rectangles R1 and R2. Return
28671 the intersection in *RESULT. Value is non-zero if RESULT is not
28675 x_intersect_rectangles (XRectangle
*r1
, XRectangle
*r2
, XRectangle
*result
)
28677 XRectangle
*left
, *right
;
28678 XRectangle
*upper
, *lower
;
28679 int intersection_p
= 0;
28681 /* Rearrange so that R1 is the left-most rectangle. */
28683 left
= r1
, right
= r2
;
28685 left
= r2
, right
= r1
;
28687 /* X0 of the intersection is right.x0, if this is inside R1,
28688 otherwise there is no intersection. */
28689 if (right
->x
<= left
->x
+ left
->width
)
28691 result
->x
= right
->x
;
28693 /* The right end of the intersection is the minimum of
28694 the right ends of left and right. */
28695 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
28698 /* Same game for Y. */
28700 upper
= r1
, lower
= r2
;
28702 upper
= r2
, lower
= r1
;
28704 /* The upper end of the intersection is lower.y0, if this is inside
28705 of upper. Otherwise, there is no intersection. */
28706 if (lower
->y
<= upper
->y
+ upper
->height
)
28708 result
->y
= lower
->y
;
28710 /* The lower end of the intersection is the minimum of the lower
28711 ends of upper and lower. */
28712 result
->height
= (min (lower
->y
+ lower
->height
,
28713 upper
->y
+ upper
->height
)
28715 intersection_p
= 1;
28719 return intersection_p
;
28722 #endif /* HAVE_WINDOW_SYSTEM */
28725 /***********************************************************************
28727 ***********************************************************************/
28730 syms_of_xdisp (void)
28732 Vwith_echo_area_save_vector
= Qnil
;
28733 staticpro (&Vwith_echo_area_save_vector
);
28735 Vmessage_stack
= Qnil
;
28736 staticpro (&Vmessage_stack
);
28738 DEFSYM (Qinhibit_redisplay
, "inhibit-redisplay");
28739 DEFSYM (Qredisplay_internal
, "redisplay_internal (C function)");
28741 message_dolog_marker1
= Fmake_marker ();
28742 staticpro (&message_dolog_marker1
);
28743 message_dolog_marker2
= Fmake_marker ();
28744 staticpro (&message_dolog_marker2
);
28745 message_dolog_marker3
= Fmake_marker ();
28746 staticpro (&message_dolog_marker3
);
28749 defsubr (&Sdump_frame_glyph_matrix
);
28750 defsubr (&Sdump_glyph_matrix
);
28751 defsubr (&Sdump_glyph_row
);
28752 defsubr (&Sdump_tool_bar_row
);
28753 defsubr (&Strace_redisplay
);
28754 defsubr (&Strace_to_stderr
);
28756 #ifdef HAVE_WINDOW_SYSTEM
28757 defsubr (&Stool_bar_lines_needed
);
28758 defsubr (&Slookup_image_map
);
28760 defsubr (&Sformat_mode_line
);
28761 defsubr (&Sinvisible_p
);
28762 defsubr (&Scurrent_bidi_paragraph_direction
);
28764 DEFSYM (Qmenu_bar_update_hook
, "menu-bar-update-hook");
28765 DEFSYM (Qoverriding_terminal_local_map
, "overriding-terminal-local-map");
28766 DEFSYM (Qoverriding_local_map
, "overriding-local-map");
28767 DEFSYM (Qwindow_scroll_functions
, "window-scroll-functions");
28768 DEFSYM (Qwindow_text_change_functions
, "window-text-change-functions");
28769 DEFSYM (Qredisplay_end_trigger_functions
, "redisplay-end-trigger-functions");
28770 DEFSYM (Qinhibit_point_motion_hooks
, "inhibit-point-motion-hooks");
28771 DEFSYM (Qeval
, "eval");
28772 DEFSYM (QCdata
, ":data");
28773 DEFSYM (Qdisplay
, "display");
28774 DEFSYM (Qspace_width
, "space-width");
28775 DEFSYM (Qraise
, "raise");
28776 DEFSYM (Qslice
, "slice");
28777 DEFSYM (Qspace
, "space");
28778 DEFSYM (Qmargin
, "margin");
28779 DEFSYM (Qpointer
, "pointer");
28780 DEFSYM (Qleft_margin
, "left-margin");
28781 DEFSYM (Qright_margin
, "right-margin");
28782 DEFSYM (Qcenter
, "center");
28783 DEFSYM (Qline_height
, "line-height");
28784 DEFSYM (QCalign_to
, ":align-to");
28785 DEFSYM (QCrelative_width
, ":relative-width");
28786 DEFSYM (QCrelative_height
, ":relative-height");
28787 DEFSYM (QCeval
, ":eval");
28788 DEFSYM (QCpropertize
, ":propertize");
28789 DEFSYM (QCfile
, ":file");
28790 DEFSYM (Qfontified
, "fontified");
28791 DEFSYM (Qfontification_functions
, "fontification-functions");
28792 DEFSYM (Qtrailing_whitespace
, "trailing-whitespace");
28793 DEFSYM (Qescape_glyph
, "escape-glyph");
28794 DEFSYM (Qnobreak_space
, "nobreak-space");
28795 DEFSYM (Qimage
, "image");
28796 DEFSYM (Qtext
, "text");
28797 DEFSYM (Qboth
, "both");
28798 DEFSYM (Qboth_horiz
, "both-horiz");
28799 DEFSYM (Qtext_image_horiz
, "text-image-horiz");
28800 DEFSYM (QCmap
, ":map");
28801 DEFSYM (QCpointer
, ":pointer");
28802 DEFSYM (Qrect
, "rect");
28803 DEFSYM (Qcircle
, "circle");
28804 DEFSYM (Qpoly
, "poly");
28805 DEFSYM (Qmessage_truncate_lines
, "message-truncate-lines");
28806 DEFSYM (Qgrow_only
, "grow-only");
28807 DEFSYM (Qinhibit_menubar_update
, "inhibit-menubar-update");
28808 DEFSYM (Qinhibit_eval_during_redisplay
, "inhibit-eval-during-redisplay");
28809 DEFSYM (Qposition
, "position");
28810 DEFSYM (Qbuffer_position
, "buffer-position");
28811 DEFSYM (Qobject
, "object");
28812 DEFSYM (Qbar
, "bar");
28813 DEFSYM (Qhbar
, "hbar");
28814 DEFSYM (Qbox
, "box");
28815 DEFSYM (Qhollow
, "hollow");
28816 DEFSYM (Qhand
, "hand");
28817 DEFSYM (Qarrow
, "arrow");
28818 DEFSYM (Qinhibit_free_realized_faces
, "inhibit-free-realized-faces");
28820 list_of_error
= Fcons (Fcons (intern_c_string ("error"),
28821 Fcons (intern_c_string ("void-variable"), Qnil
)),
28823 staticpro (&list_of_error
);
28825 DEFSYM (Qlast_arrow_position
, "last-arrow-position");
28826 DEFSYM (Qlast_arrow_string
, "last-arrow-string");
28827 DEFSYM (Qoverlay_arrow_string
, "overlay-arrow-string");
28828 DEFSYM (Qoverlay_arrow_bitmap
, "overlay-arrow-bitmap");
28830 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
28831 staticpro (&echo_buffer
[0]);
28832 staticpro (&echo_buffer
[1]);
28834 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
28835 staticpro (&echo_area_buffer
[0]);
28836 staticpro (&echo_area_buffer
[1]);
28838 Vmessages_buffer_name
= build_pure_c_string ("*Messages*");
28839 staticpro (&Vmessages_buffer_name
);
28841 mode_line_proptrans_alist
= Qnil
;
28842 staticpro (&mode_line_proptrans_alist
);
28843 mode_line_string_list
= Qnil
;
28844 staticpro (&mode_line_string_list
);
28845 mode_line_string_face
= Qnil
;
28846 staticpro (&mode_line_string_face
);
28847 mode_line_string_face_prop
= Qnil
;
28848 staticpro (&mode_line_string_face_prop
);
28849 Vmode_line_unwind_vector
= Qnil
;
28850 staticpro (&Vmode_line_unwind_vector
);
28852 DEFSYM (Qmode_line_default_help_echo
, "mode-line-default-help-echo");
28854 help_echo_string
= Qnil
;
28855 staticpro (&help_echo_string
);
28856 help_echo_object
= Qnil
;
28857 staticpro (&help_echo_object
);
28858 help_echo_window
= Qnil
;
28859 staticpro (&help_echo_window
);
28860 previous_help_echo_string
= Qnil
;
28861 staticpro (&previous_help_echo_string
);
28862 help_echo_pos
= -1;
28864 DEFSYM (Qright_to_left
, "right-to-left");
28865 DEFSYM (Qleft_to_right
, "left-to-right");
28867 #ifdef HAVE_WINDOW_SYSTEM
28868 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p
,
28869 doc
: /* Non-nil means draw block cursor as wide as the glyph under it.
28870 For example, if a block cursor is over a tab, it will be drawn as
28871 wide as that tab on the display. */);
28872 x_stretch_cursor_p
= 0;
28875 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace
,
28876 doc
: /* Non-nil means highlight trailing whitespace.
28877 The face used for trailing whitespace is `trailing-whitespace'. */);
28878 Vshow_trailing_whitespace
= Qnil
;
28880 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display
,
28881 doc
: /* Control highlighting of non-ASCII space and hyphen chars.
28882 If the value is t, Emacs highlights non-ASCII chars which have the
28883 same appearance as an ASCII space or hyphen, using the `nobreak-space'
28884 or `escape-glyph' face respectively.
28886 U+00A0 (no-break space), U+00AD (soft hyphen), U+2010 (hyphen), and
28887 U+2011 (non-breaking hyphen) are affected.
28889 Any other non-nil value means to display these characters as a escape
28890 glyph followed by an ordinary space or hyphen.
28892 A value of nil means no special handling of these characters. */);
28893 Vnobreak_char_display
= Qt
;
28895 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer
,
28896 doc
: /* The pointer shape to show in void text areas.
28897 A value of nil means to show the text pointer. Other options are `arrow',
28898 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
28899 Vvoid_text_area_pointer
= Qarrow
;
28901 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay
,
28902 doc
: /* Non-nil means don't actually do any redisplay.
28903 This is used for internal purposes. */);
28904 Vinhibit_redisplay
= Qnil
;
28906 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string
,
28907 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
28908 Vglobal_mode_string
= Qnil
;
28910 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position
,
28911 doc
: /* Marker for where to display an arrow on top of the buffer text.
28912 This must be the beginning of a line in order to work.
28913 See also `overlay-arrow-string'. */);
28914 Voverlay_arrow_position
= Qnil
;
28916 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string
,
28917 doc
: /* String to display as an arrow in non-window frames.
28918 See also `overlay-arrow-position'. */);
28919 Voverlay_arrow_string
= build_pure_c_string ("=>");
28921 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list
,
28922 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
28923 The symbols on this list are examined during redisplay to determine
28924 where to display overlay arrows. */);
28925 Voverlay_arrow_variable_list
28926 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil
);
28928 DEFVAR_INT ("scroll-step", emacs_scroll_step
,
28929 doc
: /* The number of lines to try scrolling a window by when point moves out.
28930 If that fails to bring point back on frame, point is centered instead.
28931 If this is zero, point is always centered after it moves off frame.
28932 If you want scrolling to always be a line at a time, you should set
28933 `scroll-conservatively' to a large value rather than set this to 1. */);
28935 DEFVAR_INT ("scroll-conservatively", scroll_conservatively
,
28936 doc
: /* Scroll up to this many lines, to bring point back on screen.
28937 If point moves off-screen, redisplay will scroll by up to
28938 `scroll-conservatively' lines in order to bring point just barely
28939 onto the screen again. If that cannot be done, then redisplay
28940 recenters point as usual.
28942 If the value is greater than 100, redisplay will never recenter point,
28943 but will always scroll just enough text to bring point into view, even
28944 if you move far away.
28946 A value of zero means always recenter point if it moves off screen. */);
28947 scroll_conservatively
= 0;
28949 DEFVAR_INT ("scroll-margin", scroll_margin
,
28950 doc
: /* Number of lines of margin at the top and bottom of a window.
28951 Recenter the window whenever point gets within this many lines
28952 of the top or bottom of the window. */);
28955 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch
,
28956 doc
: /* Pixels per inch value for non-window system displays.
28957 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
28958 Vdisplay_pixels_per_inch
= make_float (72.0);
28961 DEFVAR_INT ("debug-end-pos", debug_end_pos
, doc
: /* Don't ask. */);
28964 DEFVAR_LISP ("truncate-partial-width-windows",
28965 Vtruncate_partial_width_windows
,
28966 doc
: /* Non-nil means truncate lines in windows narrower than the frame.
28967 For an integer value, truncate lines in each window narrower than the
28968 full frame width, provided the window width is less than that integer;
28969 otherwise, respect the value of `truncate-lines'.
28971 For any other non-nil value, truncate lines in all windows that do
28972 not span the full frame width.
28974 A value of nil means to respect the value of `truncate-lines'.
28976 If `word-wrap' is enabled, you might want to reduce this. */);
28977 Vtruncate_partial_width_windows
= make_number (50);
28979 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit
,
28980 doc
: /* Maximum buffer size for which line number should be displayed.
28981 If the buffer is bigger than this, the line number does not appear
28982 in the mode line. A value of nil means no limit. */);
28983 Vline_number_display_limit
= Qnil
;
28985 DEFVAR_INT ("line-number-display-limit-width",
28986 line_number_display_limit_width
,
28987 doc
: /* Maximum line width (in characters) for line number display.
28988 If the average length of the lines near point is bigger than this, then the
28989 line number may be omitted from the mode line. */);
28990 line_number_display_limit_width
= 200;
28992 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows
,
28993 doc
: /* Non-nil means highlight region even in nonselected windows. */);
28994 highlight_nonselected_windows
= 0;
28996 DEFVAR_BOOL ("multiple-frames", multiple_frames
,
28997 doc
: /* Non-nil if more than one frame is visible on this display.
28998 Minibuffer-only frames don't count, but iconified frames do.
28999 This variable is not guaranteed to be accurate except while processing
29000 `frame-title-format' and `icon-title-format'. */);
29002 DEFVAR_LISP ("frame-title-format", Vframe_title_format
,
29003 doc
: /* Template for displaying the title bar of visible frames.
29004 \(Assuming the window manager supports this feature.)
29006 This variable has the same structure as `mode-line-format', except that
29007 the %c and %l constructs are ignored. It is used only on frames for
29008 which no explicit name has been set \(see `modify-frame-parameters'). */);
29010 DEFVAR_LISP ("icon-title-format", Vicon_title_format
,
29011 doc
: /* Template for displaying the title bar of an iconified frame.
29012 \(Assuming the window manager supports this feature.)
29013 This variable has the same structure as `mode-line-format' (which see),
29014 and is used only on frames for which no explicit name has been set
29015 \(see `modify-frame-parameters'). */);
29017 = Vframe_title_format
29018 = listn (CONSTYPE_PURE
, 3,
29019 intern_c_string ("multiple-frames"),
29020 build_pure_c_string ("%b"),
29021 listn (CONSTYPE_PURE
, 4,
29022 empty_unibyte_string
,
29023 intern_c_string ("invocation-name"),
29024 build_pure_c_string ("@"),
29025 intern_c_string ("system-name")));
29027 DEFVAR_LISP ("message-log-max", Vmessage_log_max
,
29028 doc
: /* Maximum number of lines to keep in the message log buffer.
29029 If nil, disable message logging. If t, log messages but don't truncate
29030 the buffer when it becomes large. */);
29031 Vmessage_log_max
= make_number (1000);
29033 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions
,
29034 doc
: /* Functions called before redisplay, if window sizes have changed.
29035 The value should be a list of functions that take one argument.
29036 Just before redisplay, for each frame, if any of its windows have changed
29037 size since the last redisplay, or have been split or deleted,
29038 all the functions in the list are called, with the frame as argument. */);
29039 Vwindow_size_change_functions
= Qnil
;
29041 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions
,
29042 doc
: /* List of functions to call before redisplaying a window with scrolling.
29043 Each function is called with two arguments, the window and its new
29044 display-start position. Note that these functions are also called by
29045 `set-window-buffer'. Also note that the value of `window-end' is not
29046 valid when these functions are called.
29048 Warning: Do not use this feature to alter the way the window
29049 is scrolled. It is not designed for that, and such use probably won't
29051 Vwindow_scroll_functions
= Qnil
;
29053 DEFVAR_LISP ("window-text-change-functions",
29054 Vwindow_text_change_functions
,
29055 doc
: /* Functions to call in redisplay when text in the window might change. */);
29056 Vwindow_text_change_functions
= Qnil
;
29058 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions
,
29059 doc
: /* Functions called when redisplay of a window reaches the end trigger.
29060 Each function is called with two arguments, the window and the end trigger value.
29061 See `set-window-redisplay-end-trigger'. */);
29062 Vredisplay_end_trigger_functions
= Qnil
;
29064 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window
,
29065 doc
: /* Non-nil means autoselect window with mouse pointer.
29066 If nil, do not autoselect windows.
29067 A positive number means delay autoselection by that many seconds: a
29068 window is autoselected only after the mouse has remained in that
29069 window for the duration of the delay.
29070 A negative number has a similar effect, but causes windows to be
29071 autoselected only after the mouse has stopped moving. \(Because of
29072 the way Emacs compares mouse events, you will occasionally wait twice
29073 that time before the window gets selected.\)
29074 Any other value means to autoselect window instantaneously when the
29075 mouse pointer enters it.
29077 Autoselection selects the minibuffer only if it is active, and never
29078 unselects the minibuffer if it is active.
29080 When customizing this variable make sure that the actual value of
29081 `focus-follows-mouse' matches the behavior of your window manager. */);
29082 Vmouse_autoselect_window
= Qnil
;
29084 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars
,
29085 doc
: /* Non-nil means automatically resize tool-bars.
29086 This dynamically changes the tool-bar's height to the minimum height
29087 that is needed to make all tool-bar items visible.
29088 If value is `grow-only', the tool-bar's height is only increased
29089 automatically; to decrease the tool-bar height, use \\[recenter]. */);
29090 Vauto_resize_tool_bars
= Qt
;
29092 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p
,
29093 doc
: /* Non-nil means raise tool-bar buttons when the mouse moves over them. */);
29094 auto_raise_tool_bar_buttons_p
= 1;
29096 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p
,
29097 doc
: /* Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
29098 make_cursor_line_fully_visible_p
= 1;
29100 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border
,
29101 doc
: /* Border below tool-bar in pixels.
29102 If an integer, use it as the height of the border.
29103 If it is one of `internal-border-width' or `border-width', use the
29104 value of the corresponding frame parameter.
29105 Otherwise, no border is added below the tool-bar. */);
29106 Vtool_bar_border
= Qinternal_border_width
;
29108 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin
,
29109 doc
: /* Margin around tool-bar buttons in pixels.
29110 If an integer, use that for both horizontal and vertical margins.
29111 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
29112 HORZ specifying the horizontal margin, and VERT specifying the
29113 vertical margin. */);
29114 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
29116 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief
,
29117 doc
: /* Relief thickness of tool-bar buttons. */);
29118 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
29120 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style
,
29121 doc
: /* Tool bar style to use.
29123 image - show images only
29124 text - show text only
29125 both - show both, text below image
29126 both-horiz - show text to the right of the image
29127 text-image-horiz - show text to the left of the image
29128 any other - use system default or image if no system default.
29130 This variable only affects the GTK+ toolkit version of Emacs. */);
29131 Vtool_bar_style
= Qnil
;
29133 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size
,
29134 doc
: /* Maximum number of characters a label can have to be shown.
29135 The tool bar style must also show labels for this to have any effect, see
29136 `tool-bar-style'. */);
29137 tool_bar_max_label_size
= DEFAULT_TOOL_BAR_LABEL_SIZE
;
29139 DEFVAR_LISP ("fontification-functions", Vfontification_functions
,
29140 doc
: /* List of functions to call to fontify regions of text.
29141 Each function is called with one argument POS. Functions must
29142 fontify a region starting at POS in the current buffer, and give
29143 fontified regions the property `fontified'. */);
29144 Vfontification_functions
= Qnil
;
29145 Fmake_variable_buffer_local (Qfontification_functions
);
29147 DEFVAR_BOOL ("unibyte-display-via-language-environment",
29148 unibyte_display_via_language_environment
,
29149 doc
: /* Non-nil means display unibyte text according to language environment.
29150 Specifically, this means that raw bytes in the range 160-255 decimal
29151 are displayed by converting them to the equivalent multibyte characters
29152 according to the current language environment. As a result, they are
29153 displayed according to the current fontset.
29155 Note that this variable affects only how these bytes are displayed,
29156 but does not change the fact they are interpreted as raw bytes. */);
29157 unibyte_display_via_language_environment
= 0;
29159 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height
,
29160 doc
: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
29161 If a float, it specifies a fraction of the mini-window frame's height.
29162 If an integer, it specifies a number of lines. */);
29163 Vmax_mini_window_height
= make_float (0.25);
29165 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows
,
29166 doc
: /* How to resize mini-windows (the minibuffer and the echo area).
29167 A value of nil means don't automatically resize mini-windows.
29168 A value of t means resize them to fit the text displayed in them.
29169 A value of `grow-only', the default, means let mini-windows grow only;
29170 they return to their normal size when the minibuffer is closed, or the
29171 echo area becomes empty. */);
29172 Vresize_mini_windows
= Qgrow_only
;
29174 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist
,
29175 doc
: /* Alist specifying how to blink the cursor off.
29176 Each element has the form (ON-STATE . OFF-STATE). Whenever the
29177 `cursor-type' frame-parameter or variable equals ON-STATE,
29178 comparing using `equal', Emacs uses OFF-STATE to specify
29179 how to blink it off. ON-STATE and OFF-STATE are values for
29180 the `cursor-type' frame parameter.
29182 If a frame's ON-STATE has no entry in this list,
29183 the frame's other specifications determine how to blink the cursor off. */);
29184 Vblink_cursor_alist
= Qnil
;
29186 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p
,
29187 doc
: /* Allow or disallow automatic horizontal scrolling of windows.
29188 If non-nil, windows are automatically scrolled horizontally to make
29189 point visible. */);
29190 automatic_hscrolling_p
= 1;
29191 DEFSYM (Qauto_hscroll_mode
, "auto-hscroll-mode");
29193 DEFVAR_INT ("hscroll-margin", hscroll_margin
,
29194 doc
: /* How many columns away from the window edge point is allowed to get
29195 before automatic hscrolling will horizontally scroll the window. */);
29196 hscroll_margin
= 5;
29198 DEFVAR_LISP ("hscroll-step", Vhscroll_step
,
29199 doc
: /* How many columns to scroll the window when point gets too close to the edge.
29200 When point is less than `hscroll-margin' columns from the window
29201 edge, automatic hscrolling will scroll the window by the amount of columns
29202 determined by this variable. If its value is a positive integer, scroll that
29203 many columns. If it's a positive floating-point number, it specifies the
29204 fraction of the window's width to scroll. If it's nil or zero, point will be
29205 centered horizontally after the scroll. Any other value, including negative
29206 numbers, are treated as if the value were zero.
29208 Automatic hscrolling always moves point outside the scroll margin, so if
29209 point was more than scroll step columns inside the margin, the window will
29210 scroll more than the value given by the scroll step.
29212 Note that the lower bound for automatic hscrolling specified by `scroll-left'
29213 and `scroll-right' overrides this variable's effect. */);
29214 Vhscroll_step
= make_number (0);
29216 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines
,
29217 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
29218 Bind this around calls to `message' to let it take effect. */);
29219 message_truncate_lines
= 0;
29221 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook
,
29222 doc
: /* Normal hook run to update the menu bar definitions.
29223 Redisplay runs this hook before it redisplays the menu bar.
29224 This is used to update submenus such as Buffers,
29225 whose contents depend on various data. */);
29226 Vmenu_bar_update_hook
= Qnil
;
29228 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame
,
29229 doc
: /* Frame for which we are updating a menu.
29230 The enable predicate for a menu binding should check this variable. */);
29231 Vmenu_updating_frame
= Qnil
;
29233 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update
,
29234 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
29235 inhibit_menubar_update
= 0;
29237 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix
,
29238 doc
: /* Prefix prepended to all continuation lines at display time.
29239 The value may be a string, an image, or a stretch-glyph; it is
29240 interpreted in the same way as the value of a `display' text property.
29242 This variable is overridden by any `wrap-prefix' text or overlay
29245 To add a prefix to non-continuation lines, use `line-prefix'. */);
29246 Vwrap_prefix
= Qnil
;
29247 DEFSYM (Qwrap_prefix
, "wrap-prefix");
29248 Fmake_variable_buffer_local (Qwrap_prefix
);
29250 DEFVAR_LISP ("line-prefix", Vline_prefix
,
29251 doc
: /* Prefix prepended to all non-continuation lines at display time.
29252 The value may be a string, an image, or a stretch-glyph; it is
29253 interpreted in the same way as the value of a `display' text property.
29255 This variable is overridden by any `line-prefix' text or overlay
29258 To add a prefix to continuation lines, use `wrap-prefix'. */);
29259 Vline_prefix
= Qnil
;
29260 DEFSYM (Qline_prefix
, "line-prefix");
29261 Fmake_variable_buffer_local (Qline_prefix
);
29263 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay
,
29264 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
29265 inhibit_eval_during_redisplay
= 0;
29267 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces
,
29268 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
29269 inhibit_free_realized_faces
= 0;
29272 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id
,
29273 doc
: /* Inhibit try_window_id display optimization. */);
29274 inhibit_try_window_id
= 0;
29276 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing
,
29277 doc
: /* Inhibit try_window_reusing display optimization. */);
29278 inhibit_try_window_reusing
= 0;
29280 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement
,
29281 doc
: /* Inhibit try_cursor_movement display optimization. */);
29282 inhibit_try_cursor_movement
= 0;
29283 #endif /* GLYPH_DEBUG */
29285 DEFVAR_INT ("overline-margin", overline_margin
,
29286 doc
: /* Space between overline and text, in pixels.
29287 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
29288 margin to the character height. */);
29289 overline_margin
= 2;
29291 DEFVAR_INT ("underline-minimum-offset",
29292 underline_minimum_offset
,
29293 doc
: /* Minimum distance between baseline and underline.
29294 This can improve legibility of underlined text at small font sizes,
29295 particularly when using variable `x-use-underline-position-properties'
29296 with fonts that specify an UNDERLINE_POSITION relatively close to the
29297 baseline. The default value is 1. */);
29298 underline_minimum_offset
= 1;
29300 DEFVAR_BOOL ("display-hourglass", display_hourglass_p
,
29301 doc
: /* Non-nil means show an hourglass pointer, when Emacs is busy.
29302 This feature only works when on a window system that can change
29303 cursor shapes. */);
29304 display_hourglass_p
= 1;
29306 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay
,
29307 doc
: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
29308 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
29310 hourglass_atimer
= NULL
;
29311 hourglass_shown_p
= 0;
29313 DEFSYM (Qglyphless_char
, "glyphless-char");
29314 DEFSYM (Qhex_code
, "hex-code");
29315 DEFSYM (Qempty_box
, "empty-box");
29316 DEFSYM (Qthin_space
, "thin-space");
29317 DEFSYM (Qzero_width
, "zero-width");
29319 DEFSYM (Qglyphless_char_display
, "glyphless-char-display");
29320 /* Intern this now in case it isn't already done.
29321 Setting this variable twice is harmless.
29322 But don't staticpro it here--that is done in alloc.c. */
29323 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
29324 Fput (Qglyphless_char_display
, Qchar_table_extra_slots
, make_number (1));
29326 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display
,
29327 doc
: /* Char-table defining glyphless characters.
29328 Each element, if non-nil, should be one of the following:
29329 an ASCII acronym string: display this string in a box
29330 `hex-code': display the hexadecimal code of a character in a box
29331 `empty-box': display as an empty box
29332 `thin-space': display as 1-pixel width space
29333 `zero-width': don't display
29334 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
29335 display method for graphical terminals and text terminals respectively.
29336 GRAPHICAL and TEXT should each have one of the values listed above.
29338 The char-table has one extra slot to control the display of a character for
29339 which no font is found. This slot only takes effect on graphical terminals.
29340 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
29341 `thin-space'. The default is `empty-box'. */);
29342 Vglyphless_char_display
= Fmake_char_table (Qglyphless_char_display
, Qnil
);
29343 Fset_char_table_extra_slot (Vglyphless_char_display
, make_number (0),
29346 DEFVAR_LISP ("debug-on-message", Vdebug_on_message
,
29347 doc
: /* If non-nil, debug if a message matching this regexp is displayed. */);
29348 Vdebug_on_message
= Qnil
;
29352 /* Initialize this module when Emacs starts. */
29357 current_header_line_height
= current_mode_line_height
= -1;
29359 CHARPOS (this_line_start_pos
) = 0;
29361 if (!noninteractive
)
29363 struct window
*m
= XWINDOW (minibuf_window
);
29364 Lisp_Object frame
= m
->frame
;
29365 struct frame
*f
= XFRAME (frame
);
29366 Lisp_Object root
= FRAME_ROOT_WINDOW (f
);
29367 struct window
*r
= XWINDOW (root
);
29370 echo_area_window
= minibuf_window
;
29372 wset_top_line (r
, make_number (FRAME_TOP_MARGIN (f
)));
29374 (r
, make_number (FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
)));
29375 wset_total_cols (r
, make_number (FRAME_COLS (f
)));
29376 wset_top_line (m
, make_number (FRAME_LINES (f
) - 1));
29377 wset_total_lines (m
, make_number (1));
29378 wset_total_cols (m
, make_number (FRAME_COLS (f
)));
29380 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
29381 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
29382 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
29384 /* The default ellipsis glyphs `...'. */
29385 for (i
= 0; i
< 3; ++i
)
29386 default_invis_vector
[i
] = make_number ('.');
29390 /* Allocate the buffer for frame titles.
29391 Also used for `format-mode-line'. */
29393 mode_line_noprop_buf
= xmalloc (size
);
29394 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
29395 mode_line_noprop_ptr
= mode_line_noprop_buf
;
29396 mode_line_target
= MODE_LINE_DISPLAY
;
29399 help_echo_showing_p
= 0;
29402 /* Platform-independent portion of hourglass implementation. */
29404 /* Cancel a currently active hourglass timer, and start a new one. */
29406 start_hourglass (void)
29408 #if defined (HAVE_WINDOW_SYSTEM)
29411 cancel_hourglass ();
29413 if (INTEGERP (Vhourglass_delay
)
29414 && XINT (Vhourglass_delay
) > 0)
29415 delay
= make_emacs_time (min (XINT (Vhourglass_delay
),
29416 TYPE_MAXIMUM (time_t)),
29418 else if (FLOATP (Vhourglass_delay
)
29419 && XFLOAT_DATA (Vhourglass_delay
) > 0)
29420 delay
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (Vhourglass_delay
));
29422 delay
= make_emacs_time (DEFAULT_HOURGLASS_DELAY
, 0);
29426 extern void w32_note_current_window (void);
29427 w32_note_current_window ();
29429 #endif /* HAVE_NTGUI */
29431 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
29432 show_hourglass
, NULL
);
29437 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
29440 cancel_hourglass (void)
29442 #if defined (HAVE_WINDOW_SYSTEM)
29443 if (hourglass_atimer
)
29445 cancel_atimer (hourglass_atimer
);
29446 hourglass_atimer
= NULL
;
29449 if (hourglass_shown_p
)