1 /* Display generation from window structure and buffer text.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2011 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 Calls to get_next_display_element fill the iterator structure with
134 relevant information about the next thing to display. Calls to
135 set_iterator_to_next move the iterator to the next thing.
137 Besides this, an iterator also contains information about the
138 display environment in which glyphs for display elements are to be
139 produced. It has fields for the width and height of the display,
140 the information whether long lines are truncated or continued, a
141 current X and Y position, and lots of other stuff you can better
144 Glyphs in a desired matrix are normally constructed in a loop
145 calling get_next_display_element and then PRODUCE_GLYPHS. The call
146 to PRODUCE_GLYPHS will fill the iterator structure with pixel
147 information about the element being displayed and at the same time
148 produce glyphs for it. If the display element fits on the line
149 being displayed, set_iterator_to_next is called next, otherwise the
150 glyphs produced are discarded. The function display_line is the
151 workhorse of filling glyph rows in the desired matrix with glyphs.
152 In addition to producing glyphs, it also handles line truncation
153 and continuation, word wrap, and cursor positioning (for the
154 latter, see also set_cursor_from_row).
158 That just couldn't be all, could it? What about terminal types not
159 supporting operations on sub-windows of the screen? To update the
160 display on such a terminal, window-based glyph matrices are not
161 well suited. To be able to reuse part of the display (scrolling
162 lines up and down), we must instead have a view of the whole
163 screen. This is what `frame matrices' are for. They are a trick.
165 Frames on terminals like above have a glyph pool. Windows on such
166 a frame sub-allocate their glyph memory from their frame's glyph
167 pool. The frame itself is given its own glyph matrices. By
168 coincidence---or maybe something else---rows in window glyph
169 matrices are slices of corresponding rows in frame matrices. Thus
170 writing to window matrices implicitly updates a frame matrix which
171 provides us with the view of the whole screen that we originally
172 wanted to have without having to move many bytes around. To be
173 honest, there is a little bit more done, but not much more. If you
174 plan to extend that code, take a look at dispnew.c. The function
175 build_frame_matrix is a good starting point.
177 Bidirectional display.
179 Bidirectional display adds quite some hair to this already complex
180 design. The good news are that a large portion of that hairy stuff
181 is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
182 reordering engine which is called by set_iterator_to_next and
183 returns the next character to display in the visual order. See
184 commentary on bidi.c for more details. As far as redisplay is
185 concerned, the effect of calling bidi_move_to_visually_next, the
186 main interface of the reordering engine, is that the iterator gets
187 magically placed on the buffer or string position that is to be
188 displayed next. In other words, a linear iteration through the
189 buffer/string is replaced with a non-linear one. All the rest of
190 the redisplay is oblivious to the bidi reordering.
192 Well, almost oblivious---there are still complications, most of
193 them due to the fact that buffer and string positions no longer
194 change monotonously with glyph indices in a glyph row. Moreover,
195 for continued lines, the buffer positions may not even be
196 monotonously changing with vertical positions. Also, accounting
197 for face changes, overlays, etc. becomes more complex because
198 non-linear iteration could potentially skip many positions with
199 changes, and then cross them again on the way back...
201 One other prominent effect of bidirectional display is that some
202 paragraphs of text need to be displayed starting at the right
203 margin of the window---the so-called right-to-left, or R2L
204 paragraphs. R2L paragraphs are displayed with R2L glyph rows,
205 which have their reversed_p flag set. The bidi reordering engine
206 produces characters in such rows starting from the character which
207 should be the rightmost on display. PRODUCE_GLYPHS then reverses
208 the order, when it fills up the glyph row whose reversed_p flag is
209 set, by prepending each new glyph to what is already there, instead
210 of appending it. When the glyph row is complete, the function
211 extend_face_to_end_of_line fills the empty space to the left of the
212 leftmost character with special glyphs, which will display as,
213 well, empty. On text terminals, these special glyphs are simply
214 blank characters. On graphics terminals, there's a single stretch
215 glyph of a suitably computed width. Both the blanks and the
216 stretch glyph are given the face of the background of the line.
217 This way, the terminal-specific back-end can still draw the glyphs
218 left to right, even for R2L lines.
220 Bidirectional display and character compositions
222 Some scripts cannot be displayed by drawing each character
223 individually, because adjacent characters change each other's shape
224 on display. For example, Arabic and Indic scripts belong to this
227 Emacs display supports this by providing "character compositions",
228 most of which is implemented in composite.c. During the buffer
229 scan that delivers characters to PRODUCE_GLYPHS, if the next
230 character to be delivered is a composed character, the iteration
231 calls composition_reseat_it and next_element_from_composition. If
232 they succeed to compose the character with one or more of the
233 following characters, the whole sequence of characters that where
234 composed is recorded in the `struct composition_it' object that is
235 part of the buffer iterator. The composed sequence could produce
236 one or more font glyphs (called "grapheme clusters") on the screen.
237 Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
238 in the direction corresponding to the current bidi scan direction
239 (recorded in the scan_dir member of the `struct bidi_it' object
240 that is part of the buffer iterator). In particular, if the bidi
241 iterator currently scans the buffer backwards, the grapheme
242 clusters are delivered back to front. This reorders the grapheme
243 clusters as appropriate for the current bidi context. Note that
244 this means that the grapheme clusters are always stored in the
245 LGSTRING object (see composite.c) in the logical order.
247 Moving an iterator in bidirectional text
248 without producing glyphs
250 Note one important detail mentioned above: that the bidi reordering
251 engine, driven by the iterator, produces characters in R2L rows
252 starting at the character that will be the rightmost on display.
253 As far as the iterator is concerned, the geometry of such rows is
254 still left to right, i.e. the iterator "thinks" the first character
255 is at the leftmost pixel position. The iterator does not know that
256 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
257 delivers. This is important when functions from the move_it_*
258 family are used to get to certain screen position or to match
259 screen coordinates with buffer coordinates: these functions use the
260 iterator geometry, which is left to right even in R2L paragraphs.
261 This works well with most callers of move_it_*, because they need
262 to get to a specific column, and columns are still numbered in the
263 reading order, i.e. the rightmost character in a R2L paragraph is
264 still column zero. But some callers do not get well with this; a
265 notable example is mouse clicks that need to find the character
266 that corresponds to certain pixel coordinates. See
267 buffer_posn_from_coords in dispnew.c for how this is handled. */
275 #include "keyboard.h"
278 #include "termchar.h"
279 #include "dispextern.h"
281 #include "character.h"
284 #include "commands.h"
288 #include "termhooks.h"
289 #include "termopts.h"
290 #include "intervals.h"
293 #include "region-cache.h"
296 #include "blockinput.h"
298 #ifdef HAVE_X_WINDOWS
313 #ifndef FRAME_X_OUTPUT
314 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
317 #define INFINITY 10000000
319 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
320 Lisp_Object Qwindow_scroll_functions
;
321 static Lisp_Object Qwindow_text_change_functions
;
322 static Lisp_Object Qredisplay_end_trigger_functions
;
323 Lisp_Object Qinhibit_point_motion_hooks
;
324 static Lisp_Object QCeval
, QCpropertize
;
325 Lisp_Object QCfile
, QCdata
;
326 static Lisp_Object Qfontified
;
327 static Lisp_Object Qgrow_only
;
328 static Lisp_Object Qinhibit_eval_during_redisplay
;
329 static Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
330 static Lisp_Object Qright_to_left
, Qleft_to_right
;
333 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
336 static Lisp_Object Qarrow
, Qhand
;
339 /* Holds the list (error). */
340 static Lisp_Object list_of_error
;
342 static Lisp_Object Qfontification_functions
;
344 static Lisp_Object Qwrap_prefix
;
345 static Lisp_Object Qline_prefix
;
347 /* Non-nil means don't actually do any redisplay. */
349 Lisp_Object Qinhibit_redisplay
;
351 /* Names of text properties relevant for redisplay. */
353 Lisp_Object Qdisplay
;
355 Lisp_Object Qspace
, QCalign_to
;
356 static Lisp_Object QCrelative_width
, QCrelative_height
;
357 Lisp_Object Qleft_margin
, Qright_margin
;
358 static Lisp_Object Qspace_width
, Qraise
;
359 static Lisp_Object Qslice
;
361 static Lisp_Object Qmargin
, Qpointer
;
362 static Lisp_Object Qline_height
;
364 #ifdef HAVE_WINDOW_SYSTEM
366 /* Test if overflow newline into fringe. Called with iterator IT
367 at or past right window margin, and with IT->current_x set. */
369 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
370 (!NILP (Voverflow_newline_into_fringe) \
371 && FRAME_WINDOW_P ((IT)->f) \
372 && ((IT)->bidi_it.paragraph_dir == R2L \
373 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
374 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
375 && (IT)->current_x == (IT)->last_visible_x \
376 && (IT)->line_wrap != WORD_WRAP)
378 #else /* !HAVE_WINDOW_SYSTEM */
379 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
380 #endif /* HAVE_WINDOW_SYSTEM */
382 /* Test if the display element loaded in IT is a space or tab
383 character. This is used to determine word wrapping. */
385 #define IT_DISPLAYING_WHITESPACE(it) \
386 (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
388 /* Name of the face used to highlight trailing whitespace. */
390 static Lisp_Object Qtrailing_whitespace
;
392 /* Name and number of the face used to highlight escape glyphs. */
394 static Lisp_Object Qescape_glyph
;
396 /* Name and number of the face used to highlight non-breaking spaces. */
398 static Lisp_Object Qnobreak_space
;
400 /* The symbol `image' which is the car of the lists used to represent
401 images in Lisp. Also a tool bar style. */
405 /* The image map types. */
407 static Lisp_Object QCpointer
;
408 static Lisp_Object Qrect
, Qcircle
, Qpoly
;
410 /* Tool bar styles */
411 Lisp_Object Qboth
, Qboth_horiz
, Qtext_image_horiz
;
413 /* Non-zero means print newline to stdout before next mini-buffer
416 int noninteractive_need_newline
;
418 /* Non-zero means print newline to message log before next message. */
420 static int message_log_need_newline
;
422 /* Three markers that message_dolog uses.
423 It could allocate them itself, but that causes trouble
424 in handling memory-full errors. */
425 static Lisp_Object message_dolog_marker1
;
426 static Lisp_Object message_dolog_marker2
;
427 static Lisp_Object message_dolog_marker3
;
429 /* The buffer position of the first character appearing entirely or
430 partially on the line of the selected window which contains the
431 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
432 redisplay optimization in redisplay_internal. */
434 static struct text_pos this_line_start_pos
;
436 /* Number of characters past the end of the line above, including the
437 terminating newline. */
439 static struct text_pos this_line_end_pos
;
441 /* The vertical positions and the height of this line. */
443 static int this_line_vpos
;
444 static int this_line_y
;
445 static int this_line_pixel_height
;
447 /* X position at which this display line starts. Usually zero;
448 negative if first character is partially visible. */
450 static int this_line_start_x
;
452 /* The smallest character position seen by move_it_* functions as they
453 move across display lines. Used to set MATRIX_ROW_START_CHARPOS of
454 hscrolled lines, see display_line. */
456 static struct text_pos this_line_min_pos
;
458 /* Buffer that this_line_.* variables are referring to. */
460 static struct buffer
*this_line_buffer
;
463 /* Values of those variables at last redisplay are stored as
464 properties on `overlay-arrow-position' symbol. However, if
465 Voverlay_arrow_position is a marker, last-arrow-position is its
466 numerical position. */
468 static Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
470 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
471 properties on a symbol in overlay-arrow-variable-list. */
473 static Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
475 Lisp_Object Qmenu_bar_update_hook
;
477 /* Nonzero if an overlay arrow has been displayed in this window. */
479 static int overlay_arrow_seen
;
481 /* Number of windows showing the buffer of the selected window (or
482 another buffer with the same base buffer). keyboard.c refers to
487 /* Vector containing glyphs for an ellipsis `...'. */
489 static Lisp_Object default_invis_vector
[3];
491 /* This is the window where the echo area message was displayed. It
492 is always a mini-buffer window, but it may not be the same window
493 currently active as a mini-buffer. */
495 Lisp_Object echo_area_window
;
497 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
498 pushes the current message and the value of
499 message_enable_multibyte on the stack, the function restore_message
500 pops the stack and displays MESSAGE again. */
502 static Lisp_Object Vmessage_stack
;
504 /* Nonzero means multibyte characters were enabled when the echo area
505 message was specified. */
507 static int message_enable_multibyte
;
509 /* Nonzero if we should redraw the mode lines on the next redisplay. */
511 int update_mode_lines
;
513 /* Nonzero if window sizes or contents have changed since last
514 redisplay that finished. */
516 int windows_or_buffers_changed
;
518 /* Nonzero means a frame's cursor type has been changed. */
520 int cursor_type_changed
;
522 /* Nonzero after display_mode_line if %l was used and it displayed a
525 static int line_number_displayed
;
527 /* The name of the *Messages* buffer, a string. */
529 static Lisp_Object Vmessages_buffer_name
;
531 /* Current, index 0, and last displayed echo area message. Either
532 buffers from echo_buffers, or nil to indicate no message. */
534 Lisp_Object echo_area_buffer
[2];
536 /* The buffers referenced from echo_area_buffer. */
538 static Lisp_Object echo_buffer
[2];
540 /* A vector saved used in with_area_buffer to reduce consing. */
542 static Lisp_Object Vwith_echo_area_save_vector
;
544 /* Non-zero means display_echo_area should display the last echo area
545 message again. Set by redisplay_preserve_echo_area. */
547 static int display_last_displayed_message_p
;
549 /* Nonzero if echo area is being used by print; zero if being used by
552 static int message_buf_print
;
554 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
556 static Lisp_Object Qinhibit_menubar_update
;
557 static Lisp_Object Qmessage_truncate_lines
;
559 /* Set to 1 in clear_message to make redisplay_internal aware
560 of an emptied echo area. */
562 static int message_cleared_p
;
564 /* A scratch glyph row with contents used for generating truncation
565 glyphs. Also used in direct_output_for_insert. */
567 #define MAX_SCRATCH_GLYPHS 100
568 static struct glyph_row scratch_glyph_row
;
569 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
571 /* Ascent and height of the last line processed by move_it_to. */
573 static int last_max_ascent
, last_height
;
575 /* Non-zero if there's a help-echo in the echo area. */
577 int help_echo_showing_p
;
579 /* If >= 0, computed, exact values of mode-line and header-line height
580 to use in the macros CURRENT_MODE_LINE_HEIGHT and
581 CURRENT_HEADER_LINE_HEIGHT. */
583 int current_mode_line_height
, current_header_line_height
;
585 /* The maximum distance to look ahead for text properties. Values
586 that are too small let us call compute_char_face and similar
587 functions too often which is expensive. Values that are too large
588 let us call compute_char_face and alike too often because we
589 might not be interested in text properties that far away. */
591 #define TEXT_PROP_DISTANCE_LIMIT 100
595 /* Non-zero means print traces of redisplay if compiled with
598 int trace_redisplay_p
;
600 #endif /* GLYPH_DEBUG */
602 #ifdef DEBUG_TRACE_MOVE
603 /* Non-zero means trace with TRACE_MOVE to stderr. */
606 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
608 #define TRACE_MOVE(x) (void) 0
611 static Lisp_Object Qauto_hscroll_mode
;
613 /* Buffer being redisplayed -- for redisplay_window_error. */
615 static struct buffer
*displayed_buffer
;
617 /* Value returned from text property handlers (see below). */
622 HANDLED_RECOMPUTE_PROPS
,
623 HANDLED_OVERLAY_STRING_CONSUMED
,
627 /* A description of text properties that redisplay is interested
632 /* The name of the property. */
635 /* A unique index for the property. */
638 /* A handler function called to set up iterator IT from the property
639 at IT's current position. Value is used to steer handle_stop. */
640 enum prop_handled (*handler
) (struct it
*it
);
643 static enum prop_handled
handle_face_prop (struct it
*);
644 static enum prop_handled
handle_invisible_prop (struct it
*);
645 static enum prop_handled
handle_display_prop (struct it
*);
646 static enum prop_handled
handle_composition_prop (struct it
*);
647 static enum prop_handled
handle_overlay_change (struct it
*);
648 static enum prop_handled
handle_fontified_prop (struct it
*);
650 /* Properties handled by iterators. */
652 static struct props it_props
[] =
654 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
655 /* Handle `face' before `display' because some sub-properties of
656 `display' need to know the face. */
657 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
658 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
659 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
660 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
664 /* Value is the position described by X. If X is a marker, value is
665 the marker_position of X. Otherwise, value is X. */
667 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
669 /* Enumeration returned by some move_it_.* functions internally. */
673 /* Not used. Undefined value. */
676 /* Move ended at the requested buffer position or ZV. */
677 MOVE_POS_MATCH_OR_ZV
,
679 /* Move ended at the requested X pixel position. */
682 /* Move within a line ended at the end of a line that must be
686 /* Move within a line ended at the end of a line that would
687 be displayed truncated. */
690 /* Move within a line ended at a line end. */
694 /* This counter is used to clear the face cache every once in a while
695 in redisplay_internal. It is incremented for each redisplay.
696 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
699 #define CLEAR_FACE_CACHE_COUNT 500
700 static int clear_face_cache_count
;
702 /* Similarly for the image cache. */
704 #ifdef HAVE_WINDOW_SYSTEM
705 #define CLEAR_IMAGE_CACHE_COUNT 101
706 static int clear_image_cache_count
;
708 /* Null glyph slice */
709 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
712 /* Non-zero while redisplay_internal is in progress. */
716 static Lisp_Object Qinhibit_free_realized_faces
;
718 /* If a string, XTread_socket generates an event to display that string.
719 (The display is done in read_char.) */
721 Lisp_Object help_echo_string
;
722 Lisp_Object help_echo_window
;
723 Lisp_Object help_echo_object
;
724 EMACS_INT help_echo_pos
;
726 /* Temporary variable for XTread_socket. */
728 Lisp_Object previous_help_echo_string
;
730 /* Platform-independent portion of hourglass implementation. */
732 /* Non-zero means an hourglass cursor is currently shown. */
733 int hourglass_shown_p
;
735 /* If non-null, an asynchronous timer that, when it expires, displays
736 an hourglass cursor on all frames. */
737 struct atimer
*hourglass_atimer
;
739 /* Name of the face used to display glyphless characters. */
740 Lisp_Object Qglyphless_char
;
742 /* Symbol for the purpose of Vglyphless_char_display. */
743 static Lisp_Object Qglyphless_char_display
;
745 /* Method symbols for Vglyphless_char_display. */
746 static Lisp_Object Qhex_code
, Qempty_box
, Qthin_space
, Qzero_width
;
748 /* Default pixel width of `thin-space' display method. */
749 #define THIN_SPACE_WIDTH 1
751 /* Default number of seconds to wait before displaying an hourglass
753 #define DEFAULT_HOURGLASS_DELAY 1
756 /* Function prototypes. */
758 static void setup_for_ellipsis (struct it
*, int);
759 static void set_iterator_to_next (struct it
*, int);
760 static void mark_window_display_accurate_1 (struct window
*, int);
761 static int single_display_spec_string_p (Lisp_Object
, Lisp_Object
);
762 static int display_prop_string_p (Lisp_Object
, Lisp_Object
);
763 static int cursor_row_p (struct glyph_row
*);
764 static int redisplay_mode_lines (Lisp_Object
, int);
765 static char *decode_mode_spec_coding (Lisp_Object
, char *, int);
767 static Lisp_Object
get_it_property (struct it
*it
, Lisp_Object prop
);
769 static void handle_line_prefix (struct it
*);
771 static void pint2str (char *, int, EMACS_INT
);
772 static void pint2hrstr (char *, int, EMACS_INT
);
773 static struct text_pos
run_window_scroll_functions (Lisp_Object
,
775 static void reconsider_clip_changes (struct window
*, struct buffer
*);
776 static int text_outside_line_unchanged_p (struct window
*,
777 EMACS_INT
, EMACS_INT
);
778 static void store_mode_line_noprop_char (char);
779 static int store_mode_line_noprop (const char *, int, int);
780 static void handle_stop (struct it
*);
781 static void handle_stop_backwards (struct it
*, EMACS_INT
);
782 static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
783 static void ensure_echo_area_buffers (void);
784 static Lisp_Object
unwind_with_echo_area_buffer (Lisp_Object
);
785 static Lisp_Object
with_echo_area_buffer_unwind_data (struct window
*);
786 static int with_echo_area_buffer (struct window
*, int,
787 int (*) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
788 EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
789 static void clear_garbaged_frames (void);
790 static int current_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
791 static void pop_message (void);
792 static int truncate_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
793 static void set_message (const char *, Lisp_Object
, EMACS_INT
, int);
794 static int set_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
795 static int display_echo_area (struct window
*);
796 static int display_echo_area_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
797 static int resize_mini_window_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
798 static Lisp_Object
unwind_redisplay (Lisp_Object
);
799 static int string_char_and_length (const unsigned char *, int *);
800 static struct text_pos
display_prop_end (struct it
*, Lisp_Object
,
802 static int compute_window_start_on_continuation_line (struct window
*);
803 static Lisp_Object
safe_eval_handler (Lisp_Object
);
804 static void insert_left_trunc_glyphs (struct it
*);
805 static struct glyph_row
*get_overlay_arrow_glyph_row (struct window
*,
807 static void extend_face_to_end_of_line (struct it
*);
808 static int append_space_for_newline (struct it
*, int);
809 static int cursor_row_fully_visible_p (struct window
*, int, int);
810 static int try_scrolling (Lisp_Object
, int, EMACS_INT
, EMACS_INT
, int, int);
811 static int try_cursor_movement (Lisp_Object
, struct text_pos
, int *);
812 static int trailing_whitespace_p (EMACS_INT
);
813 static unsigned long int message_log_check_duplicate (EMACS_INT
, EMACS_INT
);
814 static void push_it (struct it
*, struct text_pos
*);
815 static void pop_it (struct it
*);
816 static void sync_frame_with_window_matrix_rows (struct window
*);
817 static void select_frame_for_redisplay (Lisp_Object
);
818 static void redisplay_internal (void);
819 static int echo_area_display (int);
820 static void redisplay_windows (Lisp_Object
);
821 static void redisplay_window (Lisp_Object
, int);
822 static Lisp_Object
redisplay_window_error (Lisp_Object
);
823 static Lisp_Object
redisplay_window_0 (Lisp_Object
);
824 static Lisp_Object
redisplay_window_1 (Lisp_Object
);
825 static int set_cursor_from_row (struct window
*, struct glyph_row
*,
826 struct glyph_matrix
*, EMACS_INT
, EMACS_INT
,
828 static int update_menu_bar (struct frame
*, int, int);
829 static int try_window_reusing_current_matrix (struct window
*);
830 static int try_window_id (struct window
*);
831 static int display_line (struct it
*);
832 static int display_mode_lines (struct window
*);
833 static int display_mode_line (struct window
*, enum face_id
, Lisp_Object
);
834 static int display_mode_element (struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int);
835 static int store_mode_line_string (const char *, Lisp_Object
, int, int, int, Lisp_Object
);
836 static const char *decode_mode_spec (struct window
*, int, int, Lisp_Object
*);
837 static void display_menu_bar (struct window
*);
838 static EMACS_INT
display_count_lines (EMACS_INT
, EMACS_INT
, EMACS_INT
,
840 static int display_string (const char *, Lisp_Object
, Lisp_Object
,
841 EMACS_INT
, EMACS_INT
, struct it
*, int, int, int, int);
842 static void compute_line_metrics (struct it
*);
843 static void run_redisplay_end_trigger_hook (struct it
*);
844 static int get_overlay_strings (struct it
*, EMACS_INT
);
845 static int get_overlay_strings_1 (struct it
*, EMACS_INT
, int);
846 static void next_overlay_string (struct it
*);
847 static void reseat (struct it
*, struct text_pos
, int);
848 static void reseat_1 (struct it
*, struct text_pos
, int);
849 static void back_to_previous_visible_line_start (struct it
*);
850 void reseat_at_previous_visible_line_start (struct it
*);
851 static void reseat_at_next_visible_line_start (struct it
*, int);
852 static int next_element_from_ellipsis (struct it
*);
853 static int next_element_from_display_vector (struct it
*);
854 static int next_element_from_string (struct it
*);
855 static int next_element_from_c_string (struct it
*);
856 static int next_element_from_buffer (struct it
*);
857 static int next_element_from_composition (struct it
*);
858 static int next_element_from_image (struct it
*);
859 static int next_element_from_stretch (struct it
*);
860 static void load_overlay_strings (struct it
*, EMACS_INT
);
861 static int init_from_display_pos (struct it
*, struct window
*,
862 struct display_pos
*);
863 static void reseat_to_string (struct it
*, const char *,
864 Lisp_Object
, EMACS_INT
, EMACS_INT
, int, int);
865 static int get_next_display_element (struct it
*);
866 static enum move_it_result
867 move_it_in_display_line_to (struct it
*, EMACS_INT
, int,
868 enum move_operation_enum
);
869 void move_it_vertically_backward (struct it
*, int);
870 static void init_to_row_start (struct it
*, struct window
*,
872 static int init_to_row_end (struct it
*, struct window
*,
874 static void back_to_previous_line_start (struct it
*);
875 static int forward_to_next_line_start (struct it
*, int *);
876 static struct text_pos
string_pos_nchars_ahead (struct text_pos
,
877 Lisp_Object
, EMACS_INT
);
878 static struct text_pos
string_pos (EMACS_INT
, Lisp_Object
);
879 static struct text_pos
c_string_pos (EMACS_INT
, const char *, int);
880 static EMACS_INT
number_of_chars (const char *, int);
881 static void compute_stop_pos (struct it
*);
882 static void compute_string_pos (struct text_pos
*, struct text_pos
,
884 static int face_before_or_after_it_pos (struct it
*, int);
885 static EMACS_INT
next_overlay_change (EMACS_INT
);
886 static int handle_display_spec (struct it
*, Lisp_Object
, Lisp_Object
,
887 Lisp_Object
, struct text_pos
*, EMACS_INT
, int);
888 static int handle_single_display_spec (struct it
*, Lisp_Object
,
889 Lisp_Object
, Lisp_Object
,
890 struct text_pos
*, EMACS_INT
, int, int);
891 static int underlying_face_id (struct it
*);
892 static int in_ellipses_for_invisible_text_p (struct display_pos
*,
895 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
896 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
898 #ifdef HAVE_WINDOW_SYSTEM
900 static void x_consider_frame_title (Lisp_Object
);
901 static int tool_bar_lines_needed (struct frame
*, int *);
902 static void update_tool_bar (struct frame
*, int);
903 static void build_desired_tool_bar_string (struct frame
*f
);
904 static int redisplay_tool_bar (struct frame
*);
905 static void display_tool_bar_line (struct it
*, int);
906 static void notice_overwritten_cursor (struct window
*,
909 static void append_stretch_glyph (struct it
*, Lisp_Object
,
913 #endif /* HAVE_WINDOW_SYSTEM */
915 static void show_mouse_face (Mouse_HLInfo
*, enum draw_glyphs_face
);
916 static int coords_in_mouse_face_p (struct window
*, int, int);
920 /***********************************************************************
921 Window display dimensions
922 ***********************************************************************/
924 /* Return the bottom boundary y-position for text lines in window W.
925 This is the first y position at which a line cannot start.
926 It is relative to the top of the window.
928 This is the height of W minus the height of a mode line, if any. */
931 window_text_bottom_y (struct window
*w
)
933 int height
= WINDOW_TOTAL_HEIGHT (w
);
935 if (WINDOW_WANTS_MODELINE_P (w
))
936 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
940 /* Return the pixel width of display area AREA of window W. AREA < 0
941 means return the total width of W, not including fringes to
942 the left and right of the window. */
945 window_box_width (struct window
*w
, int area
)
947 int cols
= XFASTINT (w
->total_cols
);
950 if (!w
->pseudo_window_p
)
952 cols
-= WINDOW_SCROLL_BAR_COLS (w
);
954 if (area
== TEXT_AREA
)
956 if (INTEGERP (w
->left_margin_cols
))
957 cols
-= XFASTINT (w
->left_margin_cols
);
958 if (INTEGERP (w
->right_margin_cols
))
959 cols
-= XFASTINT (w
->right_margin_cols
);
960 pixels
= -WINDOW_TOTAL_FRINGE_WIDTH (w
);
962 else if (area
== LEFT_MARGIN_AREA
)
964 cols
= (INTEGERP (w
->left_margin_cols
)
965 ? XFASTINT (w
->left_margin_cols
) : 0);
968 else if (area
== RIGHT_MARGIN_AREA
)
970 cols
= (INTEGERP (w
->right_margin_cols
)
971 ? XFASTINT (w
->right_margin_cols
) : 0);
976 return cols
* WINDOW_FRAME_COLUMN_WIDTH (w
) + pixels
;
980 /* Return the pixel height of the display area of window W, not
981 including mode lines of W, if any. */
984 window_box_height (struct window
*w
)
986 struct frame
*f
= XFRAME (w
->frame
);
987 int height
= WINDOW_TOTAL_HEIGHT (w
);
989 xassert (height
>= 0);
991 /* Note: the code below that determines the mode-line/header-line
992 height is essentially the same as that contained in the macro
993 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
994 the appropriate glyph row has its `mode_line_p' flag set,
995 and if it doesn't, uses estimate_mode_line_height instead. */
997 if (WINDOW_WANTS_MODELINE_P (w
))
999 struct glyph_row
*ml_row
1000 = (w
->current_matrix
&& w
->current_matrix
->rows
1001 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1003 if (ml_row
&& ml_row
->mode_line_p
)
1004 height
-= ml_row
->height
;
1006 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1009 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1011 struct glyph_row
*hl_row
1012 = (w
->current_matrix
&& w
->current_matrix
->rows
1013 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1015 if (hl_row
&& hl_row
->mode_line_p
)
1016 height
-= hl_row
->height
;
1018 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1021 /* With a very small font and a mode-line that's taller than
1022 default, we might end up with a negative height. */
1023 return max (0, height
);
1026 /* Return the window-relative coordinate of the left edge of display
1027 area AREA of window W. AREA < 0 means return the left edge of the
1028 whole window, to the right of the left fringe of W. */
1031 window_box_left_offset (struct window
*w
, int area
)
1035 if (w
->pseudo_window_p
)
1038 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1040 if (area
== TEXT_AREA
)
1041 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1042 + window_box_width (w
, LEFT_MARGIN_AREA
));
1043 else if (area
== RIGHT_MARGIN_AREA
)
1044 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1045 + window_box_width (w
, LEFT_MARGIN_AREA
)
1046 + window_box_width (w
, TEXT_AREA
)
1047 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1049 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1050 else if (area
== LEFT_MARGIN_AREA
1051 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1052 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1058 /* Return the window-relative coordinate of the right edge of display
1059 area AREA of window W. AREA < 0 means return the right edge of the
1060 whole window, to the left of the right fringe of W. */
1063 window_box_right_offset (struct window
*w
, int area
)
1065 return window_box_left_offset (w
, area
) + window_box_width (w
, area
);
1068 /* Return the frame-relative coordinate of the left edge of display
1069 area AREA of window W. AREA < 0 means return the left edge of the
1070 whole window, to the right of the left fringe of W. */
1073 window_box_left (struct window
*w
, int area
)
1075 struct frame
*f
= XFRAME (w
->frame
);
1078 if (w
->pseudo_window_p
)
1079 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1081 x
= (WINDOW_LEFT_EDGE_X (w
)
1082 + window_box_left_offset (w
, area
));
1088 /* Return the frame-relative coordinate of the right edge of display
1089 area AREA of window W. AREA < 0 means return the right edge of the
1090 whole window, to the left of the right fringe of W. */
1093 window_box_right (struct window
*w
, int area
)
1095 return window_box_left (w
, area
) + window_box_width (w
, area
);
1098 /* Get the bounding box of the display area AREA of window W, without
1099 mode lines, in frame-relative coordinates. AREA < 0 means the
1100 whole window, not including the left and right fringes of
1101 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1102 coordinates of the upper-left corner of the box. Return in
1103 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1106 window_box (struct window
*w
, int area
, int *box_x
, int *box_y
,
1107 int *box_width
, int *box_height
)
1110 *box_width
= window_box_width (w
, area
);
1112 *box_height
= window_box_height (w
);
1114 *box_x
= window_box_left (w
, area
);
1117 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1118 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1119 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1124 /* Get the bounding box of the display area AREA of window W, without
1125 mode lines. AREA < 0 means the whole window, not including the
1126 left and right fringe of the window. Return in *TOP_LEFT_X
1127 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1128 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1129 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1133 window_box_edges (struct window
*w
, int area
, int *top_left_x
, int *top_left_y
,
1134 int *bottom_right_x
, int *bottom_right_y
)
1136 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1138 *bottom_right_x
+= *top_left_x
;
1139 *bottom_right_y
+= *top_left_y
;
1144 /***********************************************************************
1146 ***********************************************************************/
1148 /* Return the bottom y-position of the line the iterator IT is in.
1149 This can modify IT's settings. */
1152 line_bottom_y (struct it
*it
)
1154 int line_height
= it
->max_ascent
+ it
->max_descent
;
1155 int line_top_y
= it
->current_y
;
1157 if (line_height
== 0)
1160 line_height
= last_height
;
1161 else if (IT_CHARPOS (*it
) < ZV
)
1163 move_it_by_lines (it
, 1);
1164 line_height
= (it
->max_ascent
|| it
->max_descent
1165 ? it
->max_ascent
+ it
->max_descent
1170 struct glyph_row
*row
= it
->glyph_row
;
1172 /* Use the default character height. */
1173 it
->glyph_row
= NULL
;
1174 it
->what
= IT_CHARACTER
;
1177 PRODUCE_GLYPHS (it
);
1178 line_height
= it
->ascent
+ it
->descent
;
1179 it
->glyph_row
= row
;
1183 return line_top_y
+ line_height
;
1187 /* Return 1 if position CHARPOS is visible in window W.
1188 CHARPOS < 0 means return info about WINDOW_END position.
1189 If visible, set *X and *Y to pixel coordinates of top left corner.
1190 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1191 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1194 pos_visible_p (struct window
*w
, EMACS_INT charpos
, int *x
, int *y
,
1195 int *rtop
, int *rbot
, int *rowh
, int *vpos
)
1198 struct text_pos top
;
1200 struct buffer
*old_buffer
= NULL
;
1202 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w
))))
1205 if (XBUFFER (w
->buffer
) != current_buffer
)
1207 old_buffer
= current_buffer
;
1208 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1211 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1213 /* Compute exact mode line heights. */
1214 if (WINDOW_WANTS_MODELINE_P (w
))
1215 current_mode_line_height
1216 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1217 BVAR (current_buffer
, mode_line_format
));
1219 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1220 current_header_line_height
1221 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1222 BVAR (current_buffer
, header_line_format
));
1224 start_display (&it
, w
, top
);
1225 move_it_to (&it
, charpos
, -1, it
.last_visible_y
-1, -1,
1226 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1228 if (charpos
>= 0 && IT_CHARPOS (it
) >= charpos
)
1230 /* We have reached CHARPOS, or passed it. How the call to
1231 move_it_to can overshoot: (i) If CHARPOS is on invisible
1232 text, move_it_to stops at the end of the invisible text,
1233 after CHARPOS. (ii) If CHARPOS is in a display vector,
1234 move_it_to stops on its last glyph. */
1235 int top_x
= it
.current_x
;
1236 int top_y
= it
.current_y
;
1237 enum it_method it_method
= it
.method
;
1238 /* Calling line_bottom_y may change it.method, it.position, etc. */
1239 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1240 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1242 if (top_y
< window_top_y
)
1243 visible_p
= bottom_y
> window_top_y
;
1244 else if (top_y
< it
.last_visible_y
)
1248 if (it_method
== GET_FROM_DISPLAY_VECTOR
)
1250 /* We stopped on the last glyph of a display vector.
1251 Try and recompute. Hack alert! */
1252 if (charpos
< 2 || top
.charpos
>= charpos
)
1253 top_x
= it
.glyph_row
->x
;
1257 start_display (&it2
, w
, top
);
1258 move_it_to (&it2
, charpos
- 1, -1, -1, -1, MOVE_TO_POS
);
1259 get_next_display_element (&it2
);
1260 PRODUCE_GLYPHS (&it2
);
1261 if (ITERATOR_AT_END_OF_LINE_P (&it2
)
1262 || it2
.current_x
> it2
.last_visible_x
)
1263 top_x
= it
.glyph_row
->x
;
1266 top_x
= it2
.current_x
;
1267 top_y
= it2
.current_y
;
1273 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1274 *rtop
= max (0, window_top_y
- top_y
);
1275 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1276 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1277 - max (top_y
, window_top_y
)));
1286 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1287 move_it_by_lines (&it
, 1);
1288 if (charpos
< IT_CHARPOS (it
)
1289 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1292 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1294 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1295 *rtop
= max (0, -it2
.current_y
);
1296 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1297 - it
.last_visible_y
));
1298 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1300 - max (it2
.current_y
,
1301 WINDOW_HEADER_LINE_HEIGHT (w
))));
1307 set_buffer_internal_1 (old_buffer
);
1309 current_header_line_height
= current_mode_line_height
= -1;
1311 if (visible_p
&& XFASTINT (w
->hscroll
) > 0)
1312 *x
-= XFASTINT (w
->hscroll
) * WINDOW_FRAME_COLUMN_WIDTH (w
);
1315 /* Debugging code. */
1317 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1318 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1320 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1327 /* Return the next character from STR. Return in *LEN the length of
1328 the character. This is like STRING_CHAR_AND_LENGTH but never
1329 returns an invalid character. If we find one, we return a `?', but
1330 with the length of the invalid character. */
1333 string_char_and_length (const unsigned char *str
, int *len
)
1337 c
= STRING_CHAR_AND_LENGTH (str
, *len
);
1338 if (!CHAR_VALID_P (c
))
1339 /* We may not change the length here because other places in Emacs
1340 don't use this function, i.e. they silently accept invalid
1349 /* Given a position POS containing a valid character and byte position
1350 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1352 static struct text_pos
1353 string_pos_nchars_ahead (struct text_pos pos
, Lisp_Object string
, EMACS_INT nchars
)
1355 xassert (STRINGP (string
) && nchars
>= 0);
1357 if (STRING_MULTIBYTE (string
))
1359 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1364 string_char_and_length (p
, &len
);
1367 BYTEPOS (pos
) += len
;
1371 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1377 /* Value is the text position, i.e. character and byte position,
1378 for character position CHARPOS in STRING. */
1380 static inline struct text_pos
1381 string_pos (EMACS_INT charpos
, Lisp_Object string
)
1383 struct text_pos pos
;
1384 xassert (STRINGP (string
));
1385 xassert (charpos
>= 0);
1386 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1391 /* Value is a text position, i.e. character and byte position, for
1392 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1393 means recognize multibyte characters. */
1395 static struct text_pos
1396 c_string_pos (EMACS_INT charpos
, const char *s
, int multibyte_p
)
1398 struct text_pos pos
;
1400 xassert (s
!= NULL
);
1401 xassert (charpos
>= 0);
1407 SET_TEXT_POS (pos
, 0, 0);
1410 string_char_and_length ((const unsigned char *) s
, &len
);
1413 BYTEPOS (pos
) += len
;
1417 SET_TEXT_POS (pos
, charpos
, charpos
);
1423 /* Value is the number of characters in C string S. MULTIBYTE_P
1424 non-zero means recognize multibyte characters. */
1427 number_of_chars (const char *s
, int multibyte_p
)
1433 EMACS_INT rest
= strlen (s
);
1435 const unsigned char *p
= (const unsigned char *) s
;
1437 for (nchars
= 0; rest
> 0; ++nchars
)
1439 string_char_and_length (p
, &len
);
1440 rest
-= len
, p
+= len
;
1444 nchars
= strlen (s
);
1450 /* Compute byte position NEWPOS->bytepos corresponding to
1451 NEWPOS->charpos. POS is a known position in string STRING.
1452 NEWPOS->charpos must be >= POS.charpos. */
1455 compute_string_pos (struct text_pos
*newpos
, struct text_pos pos
, Lisp_Object string
)
1457 xassert (STRINGP (string
));
1458 xassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1460 if (STRING_MULTIBYTE (string
))
1461 *newpos
= string_pos_nchars_ahead (pos
, string
,
1462 CHARPOS (*newpos
) - CHARPOS (pos
));
1464 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1468 Return an estimation of the pixel height of mode or header lines on
1469 frame F. FACE_ID specifies what line's height to estimate. */
1472 estimate_mode_line_height (struct frame
*f
, enum face_id face_id
)
1474 #ifdef HAVE_WINDOW_SYSTEM
1475 if (FRAME_WINDOW_P (f
))
1477 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1479 /* This function is called so early when Emacs starts that the face
1480 cache and mode line face are not yet initialized. */
1481 if (FRAME_FACE_CACHE (f
))
1483 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1487 height
= FONT_HEIGHT (face
->font
);
1488 if (face
->box_line_width
> 0)
1489 height
+= 2 * face
->box_line_width
;
1500 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1501 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1502 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1503 not force the value into range. */
1506 pixel_to_glyph_coords (FRAME_PTR f
, register int pix_x
, register int pix_y
,
1507 int *x
, int *y
, NativeRectangle
*bounds
, int noclip
)
1510 #ifdef HAVE_WINDOW_SYSTEM
1511 if (FRAME_WINDOW_P (f
))
1513 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1514 even for negative values. */
1516 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1518 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1520 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1521 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1524 STORE_NATIVE_RECT (*bounds
,
1525 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1526 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1527 FRAME_COLUMN_WIDTH (f
) - 1,
1528 FRAME_LINE_HEIGHT (f
) - 1);
1534 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1535 pix_x
= FRAME_TOTAL_COLS (f
);
1539 else if (pix_y
> FRAME_LINES (f
))
1540 pix_y
= FRAME_LINES (f
);
1550 /* Find the glyph under window-relative coordinates X/Y in window W.
1551 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1552 strings. Return in *HPOS and *VPOS the row and column number of
1553 the glyph found. Return in *AREA the glyph area containing X.
1554 Value is a pointer to the glyph found or null if X/Y is not on
1555 text, or we can't tell because W's current matrix is not up to
1560 x_y_to_hpos_vpos (struct window
*w
, int x
, int y
, int *hpos
, int *vpos
,
1561 int *dx
, int *dy
, int *area
)
1563 struct glyph
*glyph
, *end
;
1564 struct glyph_row
*row
= NULL
;
1567 /* Find row containing Y. Give up if some row is not enabled. */
1568 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1570 row
= MATRIX_ROW (w
->current_matrix
, i
);
1571 if (!row
->enabled_p
)
1573 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1580 /* Give up if Y is not in the window. */
1581 if (i
== w
->current_matrix
->nrows
)
1584 /* Get the glyph area containing X. */
1585 if (w
->pseudo_window_p
)
1592 if (x
< window_box_left_offset (w
, TEXT_AREA
))
1594 *area
= LEFT_MARGIN_AREA
;
1595 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
1597 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
1600 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
1604 *area
= RIGHT_MARGIN_AREA
;
1605 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
1609 /* Find glyph containing X. */
1610 glyph
= row
->glyphs
[*area
];
1611 end
= glyph
+ row
->used
[*area
];
1613 while (glyph
< end
&& x
>= glyph
->pixel_width
)
1615 x
-= glyph
->pixel_width
;
1625 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
1628 *hpos
= glyph
- row
->glyphs
[*area
];
1632 /* Convert frame-relative x/y to coordinates relative to window W.
1633 Takes pseudo-windows into account. */
1636 frame_to_window_pixel_xy (struct window
*w
, int *x
, int *y
)
1638 if (w
->pseudo_window_p
)
1640 /* A pseudo-window is always full-width, and starts at the
1641 left edge of the frame, plus a frame border. */
1642 struct frame
*f
= XFRAME (w
->frame
);
1643 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
1644 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1648 *x
-= WINDOW_LEFT_EDGE_X (w
);
1649 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1653 #ifdef HAVE_WINDOW_SYSTEM
1656 Return in RECTS[] at most N clipping rectangles for glyph string S.
1657 Return the number of stored rectangles. */
1660 get_glyph_string_clip_rects (struct glyph_string
*s
, NativeRectangle
*rects
, int n
)
1667 if (s
->row
->full_width_p
)
1669 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1670 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
1671 r
.width
= WINDOW_TOTAL_WIDTH (s
->w
);
1673 /* Unless displaying a mode or menu bar line, which are always
1674 fully visible, clip to the visible part of the row. */
1675 if (s
->w
->pseudo_window_p
)
1676 r
.height
= s
->row
->visible_height
;
1678 r
.height
= s
->height
;
1682 /* This is a text line that may be partially visible. */
1683 r
.x
= window_box_left (s
->w
, s
->area
);
1684 r
.width
= window_box_width (s
->w
, s
->area
);
1685 r
.height
= s
->row
->visible_height
;
1689 if (r
.x
< s
->clip_head
->x
)
1691 if (r
.width
>= s
->clip_head
->x
- r
.x
)
1692 r
.width
-= s
->clip_head
->x
- r
.x
;
1695 r
.x
= s
->clip_head
->x
;
1698 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
1700 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
1701 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
1706 /* If S draws overlapping rows, it's sufficient to use the top and
1707 bottom of the window for clipping because this glyph string
1708 intentionally draws over other lines. */
1709 if (s
->for_overlaps
)
1711 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1712 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
1714 /* Alas, the above simple strategy does not work for the
1715 environments with anti-aliased text: if the same text is
1716 drawn onto the same place multiple times, it gets thicker.
1717 If the overlap we are processing is for the erased cursor, we
1718 take the intersection with the rectagle of the cursor. */
1719 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
1721 XRectangle rc
, r_save
= r
;
1723 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
1724 rc
.y
= s
->w
->phys_cursor
.y
;
1725 rc
.width
= s
->w
->phys_cursor_width
;
1726 rc
.height
= s
->w
->phys_cursor_height
;
1728 x_intersect_rectangles (&r_save
, &rc
, &r
);
1733 /* Don't use S->y for clipping because it doesn't take partially
1734 visible lines into account. For example, it can be negative for
1735 partially visible lines at the top of a window. */
1736 if (!s
->row
->full_width_p
1737 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
1738 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1740 r
.y
= max (0, s
->row
->y
);
1743 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
1745 /* If drawing the cursor, don't let glyph draw outside its
1746 advertised boundaries. Cleartype does this under some circumstances. */
1747 if (s
->hl
== DRAW_CURSOR
)
1749 struct glyph
*glyph
= s
->first_glyph
;
1754 r
.width
-= s
->x
- r
.x
;
1757 r
.width
= min (r
.width
, glyph
->pixel_width
);
1759 /* If r.y is below window bottom, ensure that we still see a cursor. */
1760 height
= min (glyph
->ascent
+ glyph
->descent
,
1761 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
1762 max_y
= window_text_bottom_y (s
->w
) - height
;
1763 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
1764 if (s
->ybase
- glyph
->ascent
> max_y
)
1771 /* Don't draw cursor glyph taller than our actual glyph. */
1772 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
1773 if (height
< r
.height
)
1775 max_y
= r
.y
+ r
.height
;
1776 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
1777 r
.height
= min (max_y
- r
.y
, height
);
1784 XRectangle r_save
= r
;
1786 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
1790 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
1791 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
1793 #ifdef CONVERT_FROM_XRECT
1794 CONVERT_FROM_XRECT (r
, *rects
);
1802 /* If we are processing overlapping and allowed to return
1803 multiple clipping rectangles, we exclude the row of the glyph
1804 string from the clipping rectangle. This is to avoid drawing
1805 the same text on the environment with anti-aliasing. */
1806 #ifdef CONVERT_FROM_XRECT
1809 XRectangle
*rs
= rects
;
1811 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
1813 if (s
->for_overlaps
& OVERLAPS_PRED
)
1816 if (r
.y
+ r
.height
> row_y
)
1819 rs
[i
].height
= row_y
- r
.y
;
1825 if (s
->for_overlaps
& OVERLAPS_SUCC
)
1828 if (r
.y
< row_y
+ s
->row
->visible_height
)
1830 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
1832 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
1833 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
1842 #ifdef CONVERT_FROM_XRECT
1843 for (i
= 0; i
< n
; i
++)
1844 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
1851 Return in *NR the clipping rectangle for glyph string S. */
1854 get_glyph_string_clip_rect (struct glyph_string
*s
, NativeRectangle
*nr
)
1856 get_glyph_string_clip_rects (s
, nr
, 1);
1861 Return the position and height of the phys cursor in window W.
1862 Set w->phys_cursor_width to width of phys cursor.
1866 get_phys_cursor_geometry (struct window
*w
, struct glyph_row
*row
,
1867 struct glyph
*glyph
, int *xp
, int *yp
, int *heightp
)
1869 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1870 int x
, y
, wd
, h
, h0
, y0
;
1872 /* Compute the width of the rectangle to draw. If on a stretch
1873 glyph, and `x-stretch-block-cursor' is nil, don't draw a
1874 rectangle as wide as the glyph, but use a canonical character
1876 wd
= glyph
->pixel_width
- 1;
1877 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
1881 x
= w
->phys_cursor
.x
;
1888 if (glyph
->type
== STRETCH_GLYPH
1889 && !x_stretch_cursor_p
)
1890 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
1891 w
->phys_cursor_width
= wd
;
1893 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
1895 /* If y is below window bottom, ensure that we still see a cursor. */
1896 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
1898 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
1899 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
1901 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
1904 h
= max (h
- (y0
- y
) + 1, h0
);
1909 y0
= window_text_bottom_y (w
) - h0
;
1917 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
1918 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
1923 * Remember which glyph the mouse is over.
1927 remember_mouse_glyph (struct frame
*f
, int gx
, int gy
, NativeRectangle
*rect
)
1931 struct glyph_row
*r
, *gr
, *end_row
;
1932 enum window_part part
;
1933 enum glyph_row_area area
;
1934 int x
, y
, width
, height
;
1936 /* Try to determine frame pixel position and size of the glyph under
1937 frame pixel coordinates X/Y on frame F. */
1939 if (!f
->glyphs_initialized_p
1940 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, 0),
1943 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
1944 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1948 w
= XWINDOW (window
);
1949 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
1950 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
1952 x
= window_relative_x_coord (w
, part
, gx
);
1953 y
= gy
- WINDOW_TOP_EDGE_Y (w
);
1955 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1956 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
1958 if (w
->pseudo_window_p
)
1961 part
= ON_MODE_LINE
; /* Don't adjust margin. */
1967 case ON_LEFT_MARGIN
:
1968 area
= LEFT_MARGIN_AREA
;
1971 case ON_RIGHT_MARGIN
:
1972 area
= RIGHT_MARGIN_AREA
;
1975 case ON_HEADER_LINE
:
1977 gr
= (part
== ON_HEADER_LINE
1978 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1979 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
1982 goto text_glyph_row_found
;
1989 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
1990 if (r
->y
+ r
->height
> y
)
1996 text_glyph_row_found
:
1999 struct glyph
*g
= gr
->glyphs
[area
];
2000 struct glyph
*end
= g
+ gr
->used
[area
];
2002 height
= gr
->height
;
2003 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2004 if (gx
+ g
->pixel_width
> x
)
2009 if (g
->type
== IMAGE_GLYPH
)
2011 /* Don't remember when mouse is over image, as
2012 image may have hot-spots. */
2013 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2016 width
= g
->pixel_width
;
2020 /* Use nominal char spacing at end of line. */
2022 gx
+= (x
/ width
) * width
;
2025 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2026 gx
+= window_box_left_offset (w
, area
);
2030 /* Use nominal line height at end of window. */
2031 gx
= (x
/ width
) * width
;
2033 gy
+= (y
/ height
) * height
;
2037 case ON_LEFT_FRINGE
:
2038 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2039 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2040 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2041 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2044 case ON_RIGHT_FRINGE
:
2045 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2046 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2047 : window_box_right_offset (w
, TEXT_AREA
));
2048 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2052 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2054 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2055 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2056 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2058 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2062 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2063 if (r
->y
+ r
->height
> y
)
2070 height
= gr
->height
;
2073 /* Use nominal line height at end of window. */
2075 gy
+= (y
/ height
) * height
;
2082 /* If there is no glyph under the mouse, then we divide the screen
2083 into a grid of the smallest glyph in the frame, and use that
2086 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2087 round down even for negative values. */
2093 gx
= (gx
/ width
) * width
;
2094 gy
= (gy
/ height
) * height
;
2099 gx
+= WINDOW_LEFT_EDGE_X (w
);
2100 gy
+= WINDOW_TOP_EDGE_Y (w
);
2103 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2105 /* Visible feedback for debugging. */
2108 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2109 f
->output_data
.x
->normal_gc
,
2110 gx
, gy
, width
, height
);
2116 #endif /* HAVE_WINDOW_SYSTEM */
2119 /***********************************************************************
2120 Lisp form evaluation
2121 ***********************************************************************/
2123 /* Error handler for safe_eval and safe_call. */
2126 safe_eval_handler (Lisp_Object arg
)
2128 add_to_log ("Error during redisplay: %S", arg
, Qnil
);
2133 /* Evaluate SEXPR and return the result, or nil if something went
2134 wrong. Prevent redisplay during the evaluation. */
2136 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
2137 Return the result, or nil if something went wrong. Prevent
2138 redisplay during the evaluation. */
2141 safe_call (ptrdiff_t nargs
, Lisp_Object
*args
)
2145 if (inhibit_eval_during_redisplay
)
2149 int count
= SPECPDL_INDEX ();
2150 struct gcpro gcpro1
;
2153 gcpro1
.nvars
= nargs
;
2154 specbind (Qinhibit_redisplay
, Qt
);
2155 /* Use Qt to ensure debugger does not run,
2156 so there is no possibility of wanting to redisplay. */
2157 val
= internal_condition_case_n (Ffuncall
, nargs
, args
, Qt
,
2160 val
= unbind_to (count
, val
);
2167 /* Call function FN with one argument ARG.
2168 Return the result, or nil if something went wrong. */
2171 safe_call1 (Lisp_Object fn
, Lisp_Object arg
)
2173 Lisp_Object args
[2];
2176 return safe_call (2, args
);
2179 static Lisp_Object Qeval
;
2182 safe_eval (Lisp_Object sexpr
)
2184 return safe_call1 (Qeval
, sexpr
);
2187 /* Call function FN with one argument ARG.
2188 Return the result, or nil if something went wrong. */
2191 safe_call2 (Lisp_Object fn
, Lisp_Object arg1
, Lisp_Object arg2
)
2193 Lisp_Object args
[3];
2197 return safe_call (3, args
);
2202 /***********************************************************************
2204 ***********************************************************************/
2208 /* Define CHECK_IT to perform sanity checks on iterators.
2209 This is for debugging. It is too slow to do unconditionally. */
2215 if (it
->method
== GET_FROM_STRING
)
2217 xassert (STRINGP (it
->string
));
2218 xassert (IT_STRING_CHARPOS (*it
) >= 0);
2222 xassert (IT_STRING_CHARPOS (*it
) < 0);
2223 if (it
->method
== GET_FROM_BUFFER
)
2225 /* Check that character and byte positions agree. */
2226 xassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2231 xassert (it
->current
.dpvec_index
>= 0);
2233 xassert (it
->current
.dpvec_index
< 0);
2236 #define CHECK_IT(IT) check_it ((IT))
2240 #define CHECK_IT(IT) (void) 0
2247 /* Check that the window end of window W is what we expect it
2248 to be---the last row in the current matrix displaying text. */
2251 check_window_end (struct window
*w
)
2253 if (!MINI_WINDOW_P (w
)
2254 && !NILP (w
->window_end_valid
))
2256 struct glyph_row
*row
;
2257 xassert ((row
= MATRIX_ROW (w
->current_matrix
,
2258 XFASTINT (w
->window_end_vpos
)),
2260 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2261 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2265 #define CHECK_WINDOW_END(W) check_window_end ((W))
2267 #else /* not GLYPH_DEBUG */
2269 #define CHECK_WINDOW_END(W) (void) 0
2271 #endif /* not GLYPH_DEBUG */
2275 /***********************************************************************
2276 Iterator initialization
2277 ***********************************************************************/
2279 /* Initialize IT for displaying current_buffer in window W, starting
2280 at character position CHARPOS. CHARPOS < 0 means that no buffer
2281 position is specified which is useful when the iterator is assigned
2282 a position later. BYTEPOS is the byte position corresponding to
2283 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2285 If ROW is not null, calls to produce_glyphs with IT as parameter
2286 will produce glyphs in that row.
2288 BASE_FACE_ID is the id of a base face to use. It must be one of
2289 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2290 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2291 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2293 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2294 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2295 will be initialized to use the corresponding mode line glyph row of
2296 the desired matrix of W. */
2299 init_iterator (struct it
*it
, struct window
*w
,
2300 EMACS_INT charpos
, EMACS_INT bytepos
,
2301 struct glyph_row
*row
, enum face_id base_face_id
)
2303 int highlight_region_p
;
2304 enum face_id remapped_base_face_id
= base_face_id
;
2306 /* Some precondition checks. */
2307 xassert (w
!= NULL
&& it
!= NULL
);
2308 xassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2311 /* If face attributes have been changed since the last redisplay,
2312 free realized faces now because they depend on face definitions
2313 that might have changed. Don't free faces while there might be
2314 desired matrices pending which reference these faces. */
2315 if (face_change_count
&& !inhibit_free_realized_faces
)
2317 face_change_count
= 0;
2318 free_all_realized_faces (Qnil
);
2321 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2322 if (! NILP (Vface_remapping_alist
))
2323 remapped_base_face_id
= lookup_basic_face (XFRAME (w
->frame
), base_face_id
);
2325 /* Use one of the mode line rows of W's desired matrix if
2329 if (base_face_id
== MODE_LINE_FACE_ID
2330 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2331 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2332 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2333 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2337 memset (it
, 0, sizeof *it
);
2338 it
->current
.overlay_string_index
= -1;
2339 it
->current
.dpvec_index
= -1;
2340 it
->base_face_id
= remapped_base_face_id
;
2342 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2344 /* The window in which we iterate over current_buffer: */
2345 XSETWINDOW (it
->window
, w
);
2347 it
->f
= XFRAME (w
->frame
);
2351 /* Extra space between lines (on window systems only). */
2352 if (base_face_id
== DEFAULT_FACE_ID
2353 && FRAME_WINDOW_P (it
->f
))
2355 if (NATNUMP (BVAR (current_buffer
, extra_line_spacing
)))
2356 it
->extra_line_spacing
= XFASTINT (BVAR (current_buffer
, extra_line_spacing
));
2357 else if (FLOATP (BVAR (current_buffer
, extra_line_spacing
)))
2358 it
->extra_line_spacing
= (XFLOAT_DATA (BVAR (current_buffer
, extra_line_spacing
))
2359 * FRAME_LINE_HEIGHT (it
->f
));
2360 else if (it
->f
->extra_line_spacing
> 0)
2361 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2362 it
->max_extra_line_spacing
= 0;
2365 /* If realized faces have been removed, e.g. because of face
2366 attribute changes of named faces, recompute them. When running
2367 in batch mode, the face cache of the initial frame is null. If
2368 we happen to get called, make a dummy face cache. */
2369 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2370 init_frame_faces (it
->f
);
2371 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2372 recompute_basic_faces (it
->f
);
2374 /* Current value of the `slice', `space-width', and 'height' properties. */
2375 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2376 it
->space_width
= Qnil
;
2377 it
->font_height
= Qnil
;
2378 it
->override_ascent
= -1;
2380 /* Are control characters displayed as `^C'? */
2381 it
->ctl_arrow_p
= !NILP (BVAR (current_buffer
, ctl_arrow
));
2383 /* -1 means everything between a CR and the following line end
2384 is invisible. >0 means lines indented more than this value are
2386 it
->selective
= (INTEGERP (BVAR (current_buffer
, selective_display
))
2387 ? XFASTINT (BVAR (current_buffer
, selective_display
))
2388 : (!NILP (BVAR (current_buffer
, selective_display
))
2390 it
->selective_display_ellipsis_p
2391 = !NILP (BVAR (current_buffer
, selective_display_ellipses
));
2393 /* Display table to use. */
2394 it
->dp
= window_display_table (w
);
2396 /* Are multibyte characters enabled in current_buffer? */
2397 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
2399 /* Do we need to reorder bidirectional text? Not if this is a
2400 unibyte buffer: by definition, none of the single-byte characters
2401 are strong R2L, so no reordering is needed. And bidi.c doesn't
2402 support unibyte buffers anyway. */
2404 = !NILP (BVAR (current_buffer
, bidi_display_reordering
)) && it
->multibyte_p
;
2406 /* Non-zero if we should highlight the region. */
2408 = (!NILP (Vtransient_mark_mode
)
2409 && !NILP (BVAR (current_buffer
, mark_active
))
2410 && XMARKER (BVAR (current_buffer
, mark
))->buffer
!= 0);
2412 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2413 start and end of a visible region in window IT->w. Set both to
2414 -1 to indicate no region. */
2415 if (highlight_region_p
2416 /* Maybe highlight only in selected window. */
2417 && (/* Either show region everywhere. */
2418 highlight_nonselected_windows
2419 /* Or show region in the selected window. */
2420 || w
== XWINDOW (selected_window
)
2421 /* Or show the region if we are in the mini-buffer and W is
2422 the window the mini-buffer refers to. */
2423 || (MINI_WINDOW_P (XWINDOW (selected_window
))
2424 && WINDOWP (minibuf_selected_window
)
2425 && w
== XWINDOW (minibuf_selected_window
))))
2427 EMACS_INT markpos
= marker_position (BVAR (current_buffer
, mark
));
2428 it
->region_beg_charpos
= min (PT
, markpos
);
2429 it
->region_end_charpos
= max (PT
, markpos
);
2432 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
2434 /* Get the position at which the redisplay_end_trigger hook should
2435 be run, if it is to be run at all. */
2436 if (MARKERP (w
->redisplay_end_trigger
)
2437 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2438 it
->redisplay_end_trigger_charpos
2439 = marker_position (w
->redisplay_end_trigger
);
2440 else if (INTEGERP (w
->redisplay_end_trigger
))
2441 it
->redisplay_end_trigger_charpos
= XINT (w
->redisplay_end_trigger
);
2443 /* Correct bogus values of tab_width. */
2444 it
->tab_width
= XINT (BVAR (current_buffer
, tab_width
));
2445 if (it
->tab_width
<= 0 || it
->tab_width
> 1000)
2448 /* Are lines in the display truncated? */
2449 if (base_face_id
!= DEFAULT_FACE_ID
2450 || XINT (it
->w
->hscroll
)
2451 || (! WINDOW_FULL_WIDTH_P (it
->w
)
2452 && ((!NILP (Vtruncate_partial_width_windows
)
2453 && !INTEGERP (Vtruncate_partial_width_windows
))
2454 || (INTEGERP (Vtruncate_partial_width_windows
)
2455 && (WINDOW_TOTAL_COLS (it
->w
)
2456 < XINT (Vtruncate_partial_width_windows
))))))
2457 it
->line_wrap
= TRUNCATE
;
2458 else if (NILP (BVAR (current_buffer
, truncate_lines
)))
2459 it
->line_wrap
= NILP (BVAR (current_buffer
, word_wrap
))
2460 ? WINDOW_WRAP
: WORD_WRAP
;
2462 it
->line_wrap
= TRUNCATE
;
2464 /* Get dimensions of truncation and continuation glyphs. These are
2465 displayed as fringe bitmaps under X, so we don't need them for such
2467 if (!FRAME_WINDOW_P (it
->f
))
2469 if (it
->line_wrap
== TRUNCATE
)
2471 /* We will need the truncation glyph. */
2472 xassert (it
->glyph_row
== NULL
);
2473 produce_special_glyphs (it
, IT_TRUNCATION
);
2474 it
->truncation_pixel_width
= it
->pixel_width
;
2478 /* We will need the continuation glyph. */
2479 xassert (it
->glyph_row
== NULL
);
2480 produce_special_glyphs (it
, IT_CONTINUATION
);
2481 it
->continuation_pixel_width
= it
->pixel_width
;
2484 /* Reset these values to zero because the produce_special_glyphs
2485 above has changed them. */
2486 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2487 it
->phys_ascent
= it
->phys_descent
= 0;
2490 /* Set this after getting the dimensions of truncation and
2491 continuation glyphs, so that we don't produce glyphs when calling
2492 produce_special_glyphs, above. */
2493 it
->glyph_row
= row
;
2494 it
->area
= TEXT_AREA
;
2496 /* Forget any previous info about this row being reversed. */
2498 it
->glyph_row
->reversed_p
= 0;
2500 /* Get the dimensions of the display area. The display area
2501 consists of the visible window area plus a horizontally scrolled
2502 part to the left of the window. All x-values are relative to the
2503 start of this total display area. */
2504 if (base_face_id
!= DEFAULT_FACE_ID
)
2506 /* Mode lines, menu bar in terminal frames. */
2507 it
->first_visible_x
= 0;
2508 it
->last_visible_x
= WINDOW_TOTAL_WIDTH (w
);
2513 = XFASTINT (it
->w
->hscroll
) * FRAME_COLUMN_WIDTH (it
->f
);
2514 it
->last_visible_x
= (it
->first_visible_x
2515 + window_box_width (w
, TEXT_AREA
));
2517 /* If we truncate lines, leave room for the truncator glyph(s) at
2518 the right margin. Otherwise, leave room for the continuation
2519 glyph(s). Truncation and continuation glyphs are not inserted
2520 for window-based redisplay. */
2521 if (!FRAME_WINDOW_P (it
->f
))
2523 if (it
->line_wrap
== TRUNCATE
)
2524 it
->last_visible_x
-= it
->truncation_pixel_width
;
2526 it
->last_visible_x
-= it
->continuation_pixel_width
;
2529 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
2530 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
2533 /* Leave room for a border glyph. */
2534 if (!FRAME_WINDOW_P (it
->f
)
2535 && !WINDOW_RIGHTMOST_P (it
->w
))
2536 it
->last_visible_x
-= 1;
2538 it
->last_visible_y
= window_text_bottom_y (w
);
2540 /* For mode lines and alike, arrange for the first glyph having a
2541 left box line if the face specifies a box. */
2542 if (base_face_id
!= DEFAULT_FACE_ID
)
2546 it
->face_id
= remapped_base_face_id
;
2548 /* If we have a boxed mode line, make the first character appear
2549 with a left box line. */
2550 face
= FACE_FROM_ID (it
->f
, remapped_base_face_id
);
2551 if (face
->box
!= FACE_NO_BOX
)
2552 it
->start_of_box_run_p
= 1;
2555 /* If we are to reorder bidirectional text, init the bidi
2559 /* Note the paragraph direction that this buffer wants to
2561 if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
), Qleft_to_right
))
2562 it
->paragraph_embedding
= L2R
;
2563 else if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
), Qright_to_left
))
2564 it
->paragraph_embedding
= R2L
;
2566 it
->paragraph_embedding
= NEUTRAL_DIR
;
2567 bidi_init_it (charpos
, bytepos
, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
2570 /* If a buffer position was specified, set the iterator there,
2571 getting overlays and face properties from that position. */
2572 if (charpos
>= BUF_BEG (current_buffer
))
2574 it
->end_charpos
= ZV
;
2576 IT_CHARPOS (*it
) = charpos
;
2578 /* Compute byte position if not specified. */
2579 if (bytepos
< charpos
)
2580 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
2582 IT_BYTEPOS (*it
) = bytepos
;
2584 it
->start
= it
->current
;
2586 /* Compute faces etc. */
2587 reseat (it
, it
->current
.pos
, 1);
2594 /* Initialize IT for the display of window W with window start POS. */
2597 start_display (struct it
*it
, struct window
*w
, struct text_pos pos
)
2599 struct glyph_row
*row
;
2600 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
2602 row
= w
->desired_matrix
->rows
+ first_vpos
;
2603 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
2604 it
->first_vpos
= first_vpos
;
2606 /* Don't reseat to previous visible line start if current start
2607 position is in a string or image. */
2608 if (it
->method
== GET_FROM_BUFFER
&& it
->line_wrap
!= TRUNCATE
)
2610 int start_at_line_beg_p
;
2611 int first_y
= it
->current_y
;
2613 /* If window start is not at a line start, skip forward to POS to
2614 get the correct continuation lines width. */
2615 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
2616 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
2617 if (!start_at_line_beg_p
)
2621 reseat_at_previous_visible_line_start (it
);
2622 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
2624 new_x
= it
->current_x
+ it
->pixel_width
;
2626 /* If lines are continued, this line may end in the middle
2627 of a multi-glyph character (e.g. a control character
2628 displayed as \003, or in the middle of an overlay
2629 string). In this case move_it_to above will not have
2630 taken us to the start of the continuation line but to the
2631 end of the continued line. */
2632 if (it
->current_x
> 0
2633 && it
->line_wrap
!= TRUNCATE
/* Lines are continued. */
2634 && (/* And glyph doesn't fit on the line. */
2635 new_x
> it
->last_visible_x
2636 /* Or it fits exactly and we're on a window
2638 || (new_x
== it
->last_visible_x
2639 && FRAME_WINDOW_P (it
->f
))))
2641 if (it
->current
.dpvec_index
>= 0
2642 || it
->current
.overlay_string_index
>= 0)
2644 set_iterator_to_next (it
, 1);
2645 move_it_in_display_line_to (it
, -1, -1, 0);
2648 it
->continuation_lines_width
+= it
->current_x
;
2651 /* We're starting a new display line, not affected by the
2652 height of the continued line, so clear the appropriate
2653 fields in the iterator structure. */
2654 it
->max_ascent
= it
->max_descent
= 0;
2655 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
2657 it
->current_y
= first_y
;
2659 it
->current_x
= it
->hpos
= 0;
2665 /* Return 1 if POS is a position in ellipses displayed for invisible
2666 text. W is the window we display, for text property lookup. */
2669 in_ellipses_for_invisible_text_p (struct display_pos
*pos
, struct window
*w
)
2671 Lisp_Object prop
, window
;
2673 EMACS_INT charpos
= CHARPOS (pos
->pos
);
2675 /* If POS specifies a position in a display vector, this might
2676 be for an ellipsis displayed for invisible text. We won't
2677 get the iterator set up for delivering that ellipsis unless
2678 we make sure that it gets aware of the invisible text. */
2679 if (pos
->dpvec_index
>= 0
2680 && pos
->overlay_string_index
< 0
2681 && CHARPOS (pos
->string_pos
) < 0
2683 && (XSETWINDOW (window
, w
),
2684 prop
= Fget_char_property (make_number (charpos
),
2685 Qinvisible
, window
),
2686 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
2688 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
2690 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
2697 /* Initialize IT for stepping through current_buffer in window W,
2698 starting at position POS that includes overlay string and display
2699 vector/ control character translation position information. Value
2700 is zero if there are overlay strings with newlines at POS. */
2703 init_from_display_pos (struct it
*it
, struct window
*w
, struct display_pos
*pos
)
2705 EMACS_INT charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
2706 int i
, overlay_strings_with_newlines
= 0;
2708 /* If POS specifies a position in a display vector, this might
2709 be for an ellipsis displayed for invisible text. We won't
2710 get the iterator set up for delivering that ellipsis unless
2711 we make sure that it gets aware of the invisible text. */
2712 if (in_ellipses_for_invisible_text_p (pos
, w
))
2718 /* Keep in mind: the call to reseat in init_iterator skips invisible
2719 text, so we might end up at a position different from POS. This
2720 is only a problem when POS is a row start after a newline and an
2721 overlay starts there with an after-string, and the overlay has an
2722 invisible property. Since we don't skip invisible text in
2723 display_line and elsewhere immediately after consuming the
2724 newline before the row start, such a POS will not be in a string,
2725 but the call to init_iterator below will move us to the
2727 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
2729 /* This only scans the current chunk -- it should scan all chunks.
2730 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
2731 to 16 in 22.1 to make this a lesser problem. */
2732 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
2734 const char *s
= SSDATA (it
->overlay_strings
[i
]);
2735 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
2737 while (s
< e
&& *s
!= '\n')
2742 overlay_strings_with_newlines
= 1;
2747 /* If position is within an overlay string, set up IT to the right
2749 if (pos
->overlay_string_index
>= 0)
2753 /* If the first overlay string happens to have a `display'
2754 property for an image, the iterator will be set up for that
2755 image, and we have to undo that setup first before we can
2756 correct the overlay string index. */
2757 if (it
->method
== GET_FROM_IMAGE
)
2760 /* We already have the first chunk of overlay strings in
2761 IT->overlay_strings. Load more until the one for
2762 pos->overlay_string_index is in IT->overlay_strings. */
2763 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
2765 int n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
2766 it
->current
.overlay_string_index
= 0;
2769 load_overlay_strings (it
, 0);
2770 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
2774 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
2775 relative_index
= (it
->current
.overlay_string_index
2776 % OVERLAY_STRING_CHUNK_SIZE
);
2777 it
->string
= it
->overlay_strings
[relative_index
];
2778 xassert (STRINGP (it
->string
));
2779 it
->current
.string_pos
= pos
->string_pos
;
2780 it
->method
= GET_FROM_STRING
;
2783 if (CHARPOS (pos
->string_pos
) >= 0)
2785 /* Recorded position is not in an overlay string, but in another
2786 string. This can only be a string from a `display' property.
2787 IT should already be filled with that string. */
2788 it
->current
.string_pos
= pos
->string_pos
;
2789 xassert (STRINGP (it
->string
));
2792 /* Restore position in display vector translations, control
2793 character translations or ellipses. */
2794 if (pos
->dpvec_index
>= 0)
2796 if (it
->dpvec
== NULL
)
2797 get_next_display_element (it
);
2798 xassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
2799 it
->current
.dpvec_index
= pos
->dpvec_index
;
2803 return !overlay_strings_with_newlines
;
2807 /* Initialize IT for stepping through current_buffer in window W
2808 starting at ROW->start. */
2811 init_to_row_start (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
2813 init_from_display_pos (it
, w
, &row
->start
);
2814 it
->start
= row
->start
;
2815 it
->continuation_lines_width
= row
->continuation_lines_width
;
2820 /* Initialize IT for stepping through current_buffer in window W
2821 starting in the line following ROW, i.e. starting at ROW->end.
2822 Value is zero if there are overlay strings with newlines at ROW's
2826 init_to_row_end (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
2830 if (init_from_display_pos (it
, w
, &row
->end
))
2832 if (row
->continued_p
)
2833 it
->continuation_lines_width
2834 = row
->continuation_lines_width
+ row
->pixel_width
;
2845 /***********************************************************************
2847 ***********************************************************************/
2849 /* Called when IT reaches IT->stop_charpos. Handle text property and
2850 overlay changes. Set IT->stop_charpos to the next position where
2854 handle_stop (struct it
*it
)
2856 enum prop_handled handled
;
2857 int handle_overlay_change_p
;
2861 it
->current
.dpvec_index
= -1;
2862 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
2863 it
->ignore_overlay_strings_at_pos_p
= 0;
2866 /* Use face of preceding text for ellipsis (if invisible) */
2867 if (it
->selective_display_ellipsis_p
)
2868 it
->saved_face_id
= it
->face_id
;
2872 handled
= HANDLED_NORMALLY
;
2874 /* Call text property handlers. */
2875 for (p
= it_props
; p
->handler
; ++p
)
2877 handled
= p
->handler (it
);
2879 if (handled
== HANDLED_RECOMPUTE_PROPS
)
2881 else if (handled
== HANDLED_RETURN
)
2883 /* We still want to show before and after strings from
2884 overlays even if the actual buffer text is replaced. */
2885 if (!handle_overlay_change_p
2887 || !get_overlay_strings_1 (it
, 0, 0))
2890 setup_for_ellipsis (it
, 0);
2891 /* When handling a display spec, we might load an
2892 empty string. In that case, discard it here. We
2893 used to discard it in handle_single_display_spec,
2894 but that causes get_overlay_strings_1, above, to
2895 ignore overlay strings that we must check. */
2896 if (STRINGP (it
->string
) && !SCHARS (it
->string
))
2900 else if (STRINGP (it
->string
) && !SCHARS (it
->string
))
2904 it
->ignore_overlay_strings_at_pos_p
= 1;
2905 it
->string_from_display_prop_p
= 0;
2906 handle_overlay_change_p
= 0;
2908 handled
= HANDLED_RECOMPUTE_PROPS
;
2911 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
2912 handle_overlay_change_p
= 0;
2915 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
2917 /* Don't check for overlay strings below when set to deliver
2918 characters from a display vector. */
2919 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
2920 handle_overlay_change_p
= 0;
2922 /* Handle overlay changes.
2923 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
2924 if it finds overlays. */
2925 if (handle_overlay_change_p
)
2926 handled
= handle_overlay_change (it
);
2931 setup_for_ellipsis (it
, 0);
2935 while (handled
== HANDLED_RECOMPUTE_PROPS
);
2937 /* Determine where to stop next. */
2938 if (handled
== HANDLED_NORMALLY
)
2939 compute_stop_pos (it
);
2943 /* Compute IT->stop_charpos from text property and overlay change
2944 information for IT's current position. */
2947 compute_stop_pos (struct it
*it
)
2949 register INTERVAL iv
, next_iv
;
2950 Lisp_Object object
, limit
, position
;
2951 EMACS_INT charpos
, bytepos
;
2953 /* If nowhere else, stop at the end. */
2954 it
->stop_charpos
= it
->end_charpos
;
2956 if (STRINGP (it
->string
))
2958 /* Strings are usually short, so don't limit the search for
2960 object
= it
->string
;
2962 charpos
= IT_STRING_CHARPOS (*it
);
2963 bytepos
= IT_STRING_BYTEPOS (*it
);
2969 /* If next overlay change is in front of the current stop pos
2970 (which is IT->end_charpos), stop there. Note: value of
2971 next_overlay_change is point-max if no overlay change
2973 charpos
= IT_CHARPOS (*it
);
2974 bytepos
= IT_BYTEPOS (*it
);
2975 pos
= next_overlay_change (charpos
);
2976 if (pos
< it
->stop_charpos
)
2977 it
->stop_charpos
= pos
;
2979 /* If showing the region, we have to stop at the region
2980 start or end because the face might change there. */
2981 if (it
->region_beg_charpos
> 0)
2983 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
2984 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
2985 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
2986 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
2989 /* Set up variables for computing the stop position from text
2990 property changes. */
2991 XSETBUFFER (object
, current_buffer
);
2992 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
2995 /* Get the interval containing IT's position. Value is a null
2996 interval if there isn't such an interval. */
2997 position
= make_number (charpos
);
2998 iv
= validate_interval_range (object
, &position
, &position
, 0);
2999 if (!NULL_INTERVAL_P (iv
))
3001 Lisp_Object values_here
[LAST_PROP_IDX
];
3004 /* Get properties here. */
3005 for (p
= it_props
; p
->handler
; ++p
)
3006 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3008 /* Look for an interval following iv that has different
3010 for (next_iv
= next_interval (iv
);
3011 (!NULL_INTERVAL_P (next_iv
)
3013 || XFASTINT (limit
) > next_iv
->position
));
3014 next_iv
= next_interval (next_iv
))
3016 for (p
= it_props
; p
->handler
; ++p
)
3018 Lisp_Object new_value
;
3020 new_value
= textget (next_iv
->plist
, *p
->name
);
3021 if (!EQ (values_here
[p
->idx
], new_value
))
3029 if (!NULL_INTERVAL_P (next_iv
))
3031 if (INTEGERP (limit
)
3032 && next_iv
->position
>= XFASTINT (limit
))
3033 /* No text property change up to limit. */
3034 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3036 /* Text properties change in next_iv. */
3037 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3041 if (it
->cmp_it
.id
< 0)
3043 EMACS_INT stoppos
= it
->end_charpos
;
3045 if (it
->bidi_p
&& it
->bidi_it
.scan_dir
< 0)
3047 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
,
3048 stoppos
, it
->string
);
3051 xassert (STRINGP (it
->string
)
3052 || (it
->stop_charpos
>= BEGV
3053 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3057 /* Return the position of the next overlay change after POS in
3058 current_buffer. Value is point-max if no overlay change
3059 follows. This is like `next-overlay-change' but doesn't use
3063 next_overlay_change (EMACS_INT pos
)
3067 Lisp_Object
*overlays
;
3070 /* Get all overlays at the given position. */
3071 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3073 /* If any of these overlays ends before endpos,
3074 use its ending point instead. */
3075 for (i
= 0; i
< noverlays
; ++i
)
3080 oend
= OVERLAY_END (overlays
[i
]);
3081 oendpos
= OVERLAY_POSITION (oend
);
3082 endpos
= min (endpos
, oendpos
);
3088 /* Return the character position of a display string at or after CHARPOS.
3089 If no display string exists at or after CHARPOS, return ZV. A
3090 display string is either an overlay with `display' property whose
3091 value is a string, or a `display' text property whose value is a
3092 string. FRAME_WINDOW_P is non-zero when we are displaying a window
3095 compute_display_string_pos (EMACS_INT charpos
, int frame_window_p
)
3097 /* FIXME: Support display properties on strings (object = Qnil means
3099 Lisp_Object object
= Qnil
;
3100 Lisp_Object pos
, spec
;
3101 struct text_pos position
;
3107 /* If the character at CHARPOS is where the display string begins,
3109 pos
= make_number (charpos
);
3110 CHARPOS (position
) = charpos
;
3111 BYTEPOS (position
) = CHAR_TO_BYTE (charpos
);
3112 bufpos
= charpos
; /* FIXME! support strings as well */
3113 if (!NILP (spec
= Fget_char_property (pos
, Qdisplay
, object
))
3115 || !EQ (Fget_char_property (make_number (charpos
- 1), Qdisplay
,
3118 && handle_display_spec (NULL
, spec
, object
, Qnil
, &position
, bufpos
,
3122 /* Look forward for the first character with a `display' property
3123 that will replace the underlying text when displayed. */
3125 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3126 CHARPOS (position
) = XFASTINT (pos
);
3127 BYTEPOS (position
) = CHAR_TO_BYTE (CHARPOS (position
));
3128 if (CHARPOS (position
) >= ZV
)
3130 spec
= Fget_char_property (pos
, Qdisplay
, object
);
3131 bufpos
= CHARPOS (position
); /* FIXME! support strings as well */
3132 } while (NILP (spec
)
3133 || !handle_display_spec (NULL
, spec
, object
, Qnil
, &position
, bufpos
,
3136 return CHARPOS (position
);
3139 /* Return the character position of the end of the display string that
3140 started at CHARPOS. A display string is either an overlay with
3141 `display' property whose value is a string or a `display' text
3142 property whose value is a string. */
3144 compute_display_string_end (EMACS_INT charpos
)
3146 /* FIXME: Support display properties on strings (object = Qnil means
3148 Lisp_Object object
= Qnil
;
3149 Lisp_Object pos
= make_number (charpos
);
3154 if (NILP (Fget_char_property (pos
, Qdisplay
, object
)))
3157 /* Look forward for the first character where the `display' property
3159 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3161 return XFASTINT (pos
);
3166 /***********************************************************************
3168 ***********************************************************************/
3170 /* Handle changes in the `fontified' property of the current buffer by
3171 calling hook functions from Qfontification_functions to fontify
3174 static enum prop_handled
3175 handle_fontified_prop (struct it
*it
)
3177 Lisp_Object prop
, pos
;
3178 enum prop_handled handled
= HANDLED_NORMALLY
;
3180 if (!NILP (Vmemory_full
))
3183 /* Get the value of the `fontified' property at IT's current buffer
3184 position. (The `fontified' property doesn't have a special
3185 meaning in strings.) If the value is nil, call functions from
3186 Qfontification_functions. */
3187 if (!STRINGP (it
->string
)
3189 && !NILP (Vfontification_functions
)
3190 && !NILP (Vrun_hooks
)
3191 && (pos
= make_number (IT_CHARPOS (*it
)),
3192 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3193 /* Ignore the special cased nil value always present at EOB since
3194 no amount of fontifying will be able to change it. */
3195 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3197 int count
= SPECPDL_INDEX ();
3199 struct buffer
*obuf
= current_buffer
;
3200 int begv
= BEGV
, zv
= ZV
;
3201 int old_clip_changed
= current_buffer
->clip_changed
;
3203 val
= Vfontification_functions
;
3204 specbind (Qfontification_functions
, Qnil
);
3206 xassert (it
->end_charpos
== ZV
);
3208 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3209 safe_call1 (val
, pos
);
3212 Lisp_Object fns
, fn
;
3213 struct gcpro gcpro1
, gcpro2
;
3218 for (; CONSP (val
); val
= XCDR (val
))
3224 /* A value of t indicates this hook has a local
3225 binding; it means to run the global binding too.
3226 In a global value, t should not occur. If it
3227 does, we must ignore it to avoid an endless
3229 for (fns
= Fdefault_value (Qfontification_functions
);
3235 safe_call1 (fn
, pos
);
3239 safe_call1 (fn
, pos
);
3245 unbind_to (count
, Qnil
);
3247 /* Fontification functions routinely call `save-restriction'.
3248 Normally, this tags clip_changed, which can confuse redisplay
3249 (see discussion in Bug#6671). Since we don't perform any
3250 special handling of fontification changes in the case where
3251 `save-restriction' isn't called, there's no point doing so in
3252 this case either. So, if the buffer's restrictions are
3253 actually left unchanged, reset clip_changed. */
3254 if (obuf
== current_buffer
)
3256 if (begv
== BEGV
&& zv
== ZV
)
3257 current_buffer
->clip_changed
= old_clip_changed
;
3259 /* There isn't much we can reasonably do to protect against
3260 misbehaving fontification, but here's a fig leaf. */
3261 else if (!NILP (BVAR (obuf
, name
)))
3262 set_buffer_internal_1 (obuf
);
3264 /* The fontification code may have added/removed text.
3265 It could do even a lot worse, but let's at least protect against
3266 the most obvious case where only the text past `pos' gets changed',
3267 as is/was done in grep.el where some escapes sequences are turned
3268 into face properties (bug#7876). */
3269 it
->end_charpos
= ZV
;
3271 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3272 something. This avoids an endless loop if they failed to
3273 fontify the text for which reason ever. */
3274 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3275 handled
= HANDLED_RECOMPUTE_PROPS
;
3283 /***********************************************************************
3285 ***********************************************************************/
3287 /* Set up iterator IT from face properties at its current position.
3288 Called from handle_stop. */
3290 static enum prop_handled
3291 handle_face_prop (struct it
*it
)
3294 EMACS_INT next_stop
;
3296 if (!STRINGP (it
->string
))
3299 = face_at_buffer_position (it
->w
,
3301 it
->region_beg_charpos
,
3302 it
->region_end_charpos
,
3305 + TEXT_PROP_DISTANCE_LIMIT
),
3306 0, it
->base_face_id
);
3308 /* Is this a start of a run of characters with box face?
3309 Caveat: this can be called for a freshly initialized
3310 iterator; face_id is -1 in this case. We know that the new
3311 face will not change until limit, i.e. if the new face has a
3312 box, all characters up to limit will have one. But, as
3313 usual, we don't know whether limit is really the end. */
3314 if (new_face_id
!= it
->face_id
)
3316 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3318 /* If new face has a box but old face has not, this is
3319 the start of a run of characters with box, i.e. it has
3320 a shadow on the left side. The value of face_id of the
3321 iterator will be -1 if this is the initial call that gets
3322 the face. In this case, we have to look in front of IT's
3323 position and see whether there is a face != new_face_id. */
3324 it
->start_of_box_run_p
3325 = (new_face
->box
!= FACE_NO_BOX
3326 && (it
->face_id
>= 0
3327 || IT_CHARPOS (*it
) == BEG
3328 || new_face_id
!= face_before_it_pos (it
)));
3329 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3337 Lisp_Object from_overlay
3338 = (it
->current
.overlay_string_index
>= 0
3339 ? it
->string_overlays
[it
->current
.overlay_string_index
]
3342 /* See if we got to this string directly or indirectly from
3343 an overlay property. That includes the before-string or
3344 after-string of an overlay, strings in display properties
3345 provided by an overlay, their text properties, etc.
3347 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3348 if (! NILP (from_overlay
))
3349 for (i
= it
->sp
- 1; i
>= 0; i
--)
3351 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3353 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
];
3354 else if (! NILP (it
->stack
[i
].from_overlay
))
3355 from_overlay
= it
->stack
[i
].from_overlay
;
3357 if (!NILP (from_overlay
))
3361 if (! NILP (from_overlay
))
3363 bufpos
= IT_CHARPOS (*it
);
3364 /* For a string from an overlay, the base face depends
3365 only on text properties and ignores overlays. */
3367 = face_for_overlay_string (it
->w
,
3369 it
->region_beg_charpos
,
3370 it
->region_end_charpos
,
3373 + TEXT_PROP_DISTANCE_LIMIT
),
3381 /* For strings from a `display' property, use the face at
3382 IT's current buffer position as the base face to merge
3383 with, so that overlay strings appear in the same face as
3384 surrounding text, unless they specify their own
3386 base_face_id
= underlying_face_id (it
);
3389 new_face_id
= face_at_string_position (it
->w
,
3391 IT_STRING_CHARPOS (*it
),
3393 it
->region_beg_charpos
,
3394 it
->region_end_charpos
,
3398 /* Is this a start of a run of characters with box? Caveat:
3399 this can be called for a freshly allocated iterator; face_id
3400 is -1 is this case. We know that the new face will not
3401 change until the next check pos, i.e. if the new face has a
3402 box, all characters up to that position will have a
3403 box. But, as usual, we don't know whether that position
3404 is really the end. */
3405 if (new_face_id
!= it
->face_id
)
3407 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3408 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3410 /* If new face has a box but old face hasn't, this is the
3411 start of a run of characters with box, i.e. it has a
3412 shadow on the left side. */
3413 it
->start_of_box_run_p
3414 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
3415 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3419 it
->face_id
= new_face_id
;
3420 return HANDLED_NORMALLY
;
3424 /* Return the ID of the face ``underlying'' IT's current position,
3425 which is in a string. If the iterator is associated with a
3426 buffer, return the face at IT's current buffer position.
3427 Otherwise, use the iterator's base_face_id. */
3430 underlying_face_id (struct it
*it
)
3432 int face_id
= it
->base_face_id
, i
;
3434 xassert (STRINGP (it
->string
));
3436 for (i
= it
->sp
- 1; i
>= 0; --i
)
3437 if (NILP (it
->stack
[i
].string
))
3438 face_id
= it
->stack
[i
].face_id
;
3444 /* Compute the face one character before or after the current position
3445 of IT. BEFORE_P non-zero means get the face in front of IT's
3446 position. Value is the id of the face. */
3449 face_before_or_after_it_pos (struct it
*it
, int before_p
)
3452 EMACS_INT next_check_charpos
;
3453 struct text_pos pos
;
3455 xassert (it
->s
== NULL
);
3457 if (STRINGP (it
->string
))
3462 /* No face change past the end of the string (for the case
3463 we are padding with spaces). No face change before the
3465 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
3466 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
3469 /* Set pos to the position before or after IT's current position. */
3471 pos
= string_pos (IT_STRING_CHARPOS (*it
) - 1, it
->string
);
3473 /* For composition, we must check the character after the
3475 pos
= (it
->what
== IT_COMPOSITION
3476 ? string_pos (IT_STRING_CHARPOS (*it
)
3477 + it
->cmp_it
.nchars
, it
->string
)
3478 : string_pos (IT_STRING_CHARPOS (*it
) + 1, it
->string
));
3480 if (it
->current
.overlay_string_index
>= 0)
3481 bufpos
= IT_CHARPOS (*it
);
3485 base_face_id
= underlying_face_id (it
);
3487 /* Get the face for ASCII, or unibyte. */
3488 face_id
= face_at_string_position (it
->w
,
3492 it
->region_beg_charpos
,
3493 it
->region_end_charpos
,
3494 &next_check_charpos
,
3497 /* Correct the face for charsets different from ASCII. Do it
3498 for the multibyte case only. The face returned above is
3499 suitable for unibyte text if IT->string is unibyte. */
3500 if (STRING_MULTIBYTE (it
->string
))
3502 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos
);
3504 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3506 c
= string_char_and_length (p
, &len
);
3507 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), it
->string
);
3512 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
3513 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
3516 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
3517 pos
= it
->current
.pos
;
3520 DEC_TEXT_POS (pos
, it
->multibyte_p
);
3523 if (it
->what
== IT_COMPOSITION
)
3524 /* For composition, we must check the position after the
3526 pos
.charpos
+= it
->cmp_it
.nchars
, pos
.bytepos
+= it
->len
;
3528 INC_TEXT_POS (pos
, it
->multibyte_p
);
3531 /* Determine face for CHARSET_ASCII, or unibyte. */
3532 face_id
= face_at_buffer_position (it
->w
,
3534 it
->region_beg_charpos
,
3535 it
->region_end_charpos
,
3536 &next_check_charpos
,
3539 /* Correct the face for charsets different from ASCII. Do it
3540 for the multibyte case only. The face returned above is
3541 suitable for unibyte text if current_buffer is unibyte. */
3542 if (it
->multibyte_p
)
3544 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
3545 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3546 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
3555 /***********************************************************************
3557 ***********************************************************************/
3559 /* Set up iterator IT from invisible properties at its current
3560 position. Called from handle_stop. */
3562 static enum prop_handled
3563 handle_invisible_prop (struct it
*it
)
3565 enum prop_handled handled
= HANDLED_NORMALLY
;
3567 if (STRINGP (it
->string
))
3569 Lisp_Object prop
, end_charpos
, limit
, charpos
;
3571 /* Get the value of the invisible text property at the
3572 current position. Value will be nil if there is no such
3574 charpos
= make_number (IT_STRING_CHARPOS (*it
));
3575 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
3578 && IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
3580 handled
= HANDLED_RECOMPUTE_PROPS
;
3582 /* Get the position at which the next change of the
3583 invisible text property can be found in IT->string.
3584 Value will be nil if the property value is the same for
3585 all the rest of IT->string. */
3586 XSETINT (limit
, SCHARS (it
->string
));
3587 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
3590 /* Text at current position is invisible. The next
3591 change in the property is at position end_charpos.
3592 Move IT's current position to that position. */
3593 if (INTEGERP (end_charpos
)
3594 && XFASTINT (end_charpos
) < XFASTINT (limit
))
3596 struct text_pos old
;
3597 old
= it
->current
.string_pos
;
3598 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
3599 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
3603 /* The rest of the string is invisible. If this is an
3604 overlay string, proceed with the next overlay string
3605 or whatever comes and return a character from there. */
3606 if (it
->current
.overlay_string_index
>= 0)
3608 next_overlay_string (it
);
3609 /* Don't check for overlay strings when we just
3610 finished processing them. */
3611 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
3615 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
3616 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
3624 EMACS_INT newpos
, next_stop
, start_charpos
, tem
;
3625 Lisp_Object pos
, prop
, overlay
;
3627 /* First of all, is there invisible text at this position? */
3628 tem
= start_charpos
= IT_CHARPOS (*it
);
3629 pos
= make_number (tem
);
3630 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
3632 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3634 /* If we are on invisible text, skip over it. */
3635 if (invis_p
&& start_charpos
< it
->end_charpos
)
3637 /* Record whether we have to display an ellipsis for the
3639 int display_ellipsis_p
= invis_p
== 2;
3641 handled
= HANDLED_RECOMPUTE_PROPS
;
3643 /* Loop skipping over invisible text. The loop is left at
3644 ZV or with IT on the first char being visible again. */
3647 /* Try to skip some invisible text. Return value is the
3648 position reached which can be equal to where we start
3649 if there is nothing invisible there. This skips both
3650 over invisible text properties and overlays with
3651 invisible property. */
3652 newpos
= skip_invisible (tem
, &next_stop
, ZV
, it
->window
);
3654 /* If we skipped nothing at all we weren't at invisible
3655 text in the first place. If everything to the end of
3656 the buffer was skipped, end the loop. */
3657 if (newpos
== tem
|| newpos
>= ZV
)
3661 /* We skipped some characters but not necessarily
3662 all there are. Check if we ended up on visible
3663 text. Fget_char_property returns the property of
3664 the char before the given position, i.e. if we
3665 get invis_p = 0, this means that the char at
3666 newpos is visible. */
3667 pos
= make_number (newpos
);
3668 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
3669 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3672 /* If we ended up on invisible text, proceed to
3673 skip starting with next_stop. */
3677 /* If there are adjacent invisible texts, don't lose the
3678 second one's ellipsis. */
3680 display_ellipsis_p
= 1;
3684 /* The position newpos is now either ZV or on visible text. */
3685 if (it
->bidi_p
&& newpos
< ZV
)
3687 /* With bidi iteration, the region of invisible text
3688 could start and/or end in the middle of a non-base
3689 embedding level. Therefore, we need to skip
3690 invisible text using the bidi iterator, starting at
3691 IT's current position, until we find ourselves
3692 outside the invisible text. Skipping invisible text
3693 _after_ bidi iteration avoids affecting the visual
3694 order of the displayed text when invisible properties
3695 are added or removed. */
3696 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
3698 /* If we were `reseat'ed to a new paragraph,
3699 determine the paragraph base direction. We need
3700 to do it now because next_element_from_buffer may
3701 not have a chance to do it, if we are going to
3702 skip any text at the beginning, which resets the
3704 bidi_paragraph_init (it
->paragraph_embedding
,
3709 bidi_move_to_visually_next (&it
->bidi_it
);
3711 while (it
->stop_charpos
<= it
->bidi_it
.charpos
3712 && it
->bidi_it
.charpos
< newpos
);
3713 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
3714 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
3715 /* If we overstepped NEWPOS, record its position in the
3716 iterator, so that we skip invisible text if later the
3717 bidi iteration lands us in the invisible region
3719 if (IT_CHARPOS (*it
) >= newpos
)
3720 it
->prev_stop
= newpos
;
3724 IT_CHARPOS (*it
) = newpos
;
3725 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
3728 /* If there are before-strings at the start of invisible
3729 text, and the text is invisible because of a text
3730 property, arrange to show before-strings because 20.x did
3731 it that way. (If the text is invisible because of an
3732 overlay property instead of a text property, this is
3733 already handled in the overlay code.) */
3735 && get_overlay_strings (it
, it
->stop_charpos
))
3737 handled
= HANDLED_RECOMPUTE_PROPS
;
3738 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
3740 else if (display_ellipsis_p
)
3742 /* Make sure that the glyphs of the ellipsis will get
3743 correct `charpos' values. If we would not update
3744 it->position here, the glyphs would belong to the
3745 last visible character _before_ the invisible
3746 text, which confuses `set_cursor_from_row'.
3748 We use the last invisible position instead of the
3749 first because this way the cursor is always drawn on
3750 the first "." of the ellipsis, whenever PT is inside
3751 the invisible text. Otherwise the cursor would be
3752 placed _after_ the ellipsis when the point is after the
3753 first invisible character. */
3754 if (!STRINGP (it
->object
))
3756 it
->position
.charpos
= newpos
- 1;
3757 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
3760 /* Let the ellipsis display before
3761 considering any properties of the following char.
3762 Fixes jasonr@gnu.org 01 Oct 07 bug. */
3763 handled
= HANDLED_RETURN
;
3772 /* Make iterator IT return `...' next.
3773 Replaces LEN characters from buffer. */
3776 setup_for_ellipsis (struct it
*it
, int len
)
3778 /* Use the display table definition for `...'. Invalid glyphs
3779 will be handled by the method returning elements from dpvec. */
3780 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
3782 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
3783 it
->dpvec
= v
->contents
;
3784 it
->dpend
= v
->contents
+ v
->header
.size
;
3788 /* Default `...'. */
3789 it
->dpvec
= default_invis_vector
;
3790 it
->dpend
= default_invis_vector
+ 3;
3793 it
->dpvec_char_len
= len
;
3794 it
->current
.dpvec_index
= 0;
3795 it
->dpvec_face_id
= -1;
3797 /* Remember the current face id in case glyphs specify faces.
3798 IT's face is restored in set_iterator_to_next.
3799 saved_face_id was set to preceding char's face in handle_stop. */
3800 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
3801 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
3803 it
->method
= GET_FROM_DISPLAY_VECTOR
;
3809 /***********************************************************************
3811 ***********************************************************************/
3813 /* Set up iterator IT from `display' property at its current position.
3814 Called from handle_stop.
3815 We return HANDLED_RETURN if some part of the display property
3816 overrides the display of the buffer text itself.
3817 Otherwise we return HANDLED_NORMALLY. */
3819 static enum prop_handled
3820 handle_display_prop (struct it
*it
)
3822 Lisp_Object propval
, object
, overlay
;
3823 struct text_pos
*position
;
3825 /* Nonzero if some property replaces the display of the text itself. */
3826 int display_replaced_p
= 0;
3828 if (STRINGP (it
->string
))
3830 object
= it
->string
;
3831 position
= &it
->current
.string_pos
;
3832 bufpos
= CHARPOS (it
->current
.pos
);
3836 XSETWINDOW (object
, it
->w
);
3837 position
= &it
->current
.pos
;
3838 bufpos
= CHARPOS (*position
);
3841 /* Reset those iterator values set from display property values. */
3842 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
3843 it
->space_width
= Qnil
;
3844 it
->font_height
= Qnil
;
3847 /* We don't support recursive `display' properties, i.e. string
3848 values that have a string `display' property, that have a string
3849 `display' property etc. */
3850 if (!it
->string_from_display_prop_p
)
3851 it
->area
= TEXT_AREA
;
3853 propval
= get_char_property_and_overlay (make_number (position
->charpos
),
3854 Qdisplay
, object
, &overlay
);
3856 return HANDLED_NORMALLY
;
3857 /* Now OVERLAY is the overlay that gave us this property, or nil
3858 if it was a text property. */
3860 if (!STRINGP (it
->string
))
3861 object
= it
->w
->buffer
;
3863 display_replaced_p
= handle_display_spec (it
, propval
, object
, overlay
,
3865 FRAME_WINDOW_P (it
->f
));
3867 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
3870 /* Subroutine of handle_display_prop. Returns non-zero if the display
3871 specification in SPEC is a replacing specification, i.e. it would
3872 replace the text covered by `display' property with something else,
3873 such as an image or a display string.
3875 See handle_single_display_spec for documentation of arguments.
3876 frame_window_p is non-zero if the window being redisplayed is on a
3877 GUI frame; this argument is used only if IT is NULL, see below.
3879 IT can be NULL, if this is called by the bidi reordering code
3880 through compute_display_string_pos, which see. In that case, this
3881 function only examines SPEC, but does not otherwise "handle" it, in
3882 the sense that it doesn't set up members of IT from the display
3885 handle_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
3886 Lisp_Object overlay
, struct text_pos
*position
,
3887 EMACS_INT bufpos
, int frame_window_p
)
3889 int replacing_p
= 0;
3892 /* Simple specerties. */
3893 && !EQ (XCAR (spec
), Qimage
)
3894 && !EQ (XCAR (spec
), Qspace
)
3895 && !EQ (XCAR (spec
), Qwhen
)
3896 && !EQ (XCAR (spec
), Qslice
)
3897 && !EQ (XCAR (spec
), Qspace_width
)
3898 && !EQ (XCAR (spec
), Qheight
)
3899 && !EQ (XCAR (spec
), Qraise
)
3900 /* Marginal area specifications. */
3901 && !(CONSP (XCAR (spec
)) && EQ (XCAR (XCAR (spec
)), Qmargin
))
3902 && !EQ (XCAR (spec
), Qleft_fringe
)
3903 && !EQ (XCAR (spec
), Qright_fringe
)
3904 && !NILP (XCAR (spec
)))
3906 for (; CONSP (spec
); spec
= XCDR (spec
))
3908 if (handle_single_display_spec (it
, XCAR (spec
), object
, overlay
,
3909 position
, bufpos
, replacing_p
,
3913 /* If some text in a string is replaced, `position' no
3914 longer points to the position of `object'. */
3915 if (!it
|| STRINGP (object
))
3920 else if (VECTORP (spec
))
3923 for (i
= 0; i
< ASIZE (spec
); ++i
)
3924 if (handle_single_display_spec (it
, AREF (spec
, i
), object
, overlay
,
3925 position
, bufpos
, replacing_p
,
3929 /* If some text in a string is replaced, `position' no
3930 longer points to the position of `object'. */
3931 if (!it
|| STRINGP (object
))
3937 if (handle_single_display_spec (it
, spec
, object
, overlay
,
3938 position
, bufpos
, 0, frame_window_p
))
3945 /* Value is the position of the end of the `display' property starting
3946 at START_POS in OBJECT. */
3948 static struct text_pos
3949 display_prop_end (struct it
*it
, Lisp_Object object
, struct text_pos start_pos
)
3952 struct text_pos end_pos
;
3954 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
3955 Qdisplay
, object
, Qnil
);
3956 CHARPOS (end_pos
) = XFASTINT (end
);
3957 if (STRINGP (object
))
3958 compute_string_pos (&end_pos
, start_pos
, it
->string
);
3960 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
3966 /* Set up IT from a single `display' property specification SPEC. OBJECT
3967 is the object in which the `display' property was found. *POSITION
3968 is the position in OBJECT at which the `display' property was found.
3969 BUFPOS is the buffer position of OBJECT (different from POSITION if
3970 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
3971 previously saw a display specification which already replaced text
3972 display with something else, for example an image; we ignore such
3973 properties after the first one has been processed.
3975 OVERLAY is the overlay this `display' property came from,
3976 or nil if it was a text property.
3978 If SPEC is a `space' or `image' specification, and in some other
3979 cases too, set *POSITION to the position where the `display'
3982 If IT is NULL, only examine the property specification in SPEC, but
3983 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
3984 is intended to be displayed in a window on a GUI frame.
3986 Value is non-zero if something was found which replaces the display
3987 of buffer or string text. */
3990 handle_single_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
3991 Lisp_Object overlay
, struct text_pos
*position
,
3992 EMACS_INT bufpos
, int display_replaced_p
,
3996 Lisp_Object location
, value
;
3997 struct text_pos start_pos
= *position
;
4000 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4001 If the result is non-nil, use VALUE instead of SPEC. */
4003 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
4012 if (!NILP (form
) && !EQ (form
, Qt
))
4014 int count
= SPECPDL_INDEX ();
4015 struct gcpro gcpro1
;
4017 /* Bind `object' to the object having the `display' property, a
4018 buffer or string. Bind `position' to the position in the
4019 object where the property was found, and `buffer-position'
4020 to the current position in the buffer. */
4023 XSETBUFFER (object
, current_buffer
);
4024 specbind (Qobject
, object
);
4025 specbind (Qposition
, make_number (CHARPOS (*position
)));
4026 specbind (Qbuffer_position
, make_number (bufpos
));
4028 form
= safe_eval (form
);
4030 unbind_to (count
, Qnil
);
4036 /* Handle `(height HEIGHT)' specifications. */
4038 && EQ (XCAR (spec
), Qheight
)
4039 && CONSP (XCDR (spec
)))
4043 if (!FRAME_WINDOW_P (it
->f
))
4046 it
->font_height
= XCAR (XCDR (spec
));
4047 if (!NILP (it
->font_height
))
4049 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4050 int new_height
= -1;
4052 if (CONSP (it
->font_height
)
4053 && (EQ (XCAR (it
->font_height
), Qplus
)
4054 || EQ (XCAR (it
->font_height
), Qminus
))
4055 && CONSP (XCDR (it
->font_height
))
4056 && INTEGERP (XCAR (XCDR (it
->font_height
))))
4058 /* `(+ N)' or `(- N)' where N is an integer. */
4059 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4060 if (EQ (XCAR (it
->font_height
), Qplus
))
4062 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4064 else if (FUNCTIONP (it
->font_height
))
4066 /* Call function with current height as argument.
4067 Value is the new height. */
4069 height
= safe_call1 (it
->font_height
,
4070 face
->lface
[LFACE_HEIGHT_INDEX
]);
4071 if (NUMBERP (height
))
4072 new_height
= XFLOATINT (height
);
4074 else if (NUMBERP (it
->font_height
))
4076 /* Value is a multiple of the canonical char height. */
4079 f
= FACE_FROM_ID (it
->f
,
4080 lookup_basic_face (it
->f
, DEFAULT_FACE_ID
));
4081 new_height
= (XFLOATINT (it
->font_height
)
4082 * XINT (f
->lface
[LFACE_HEIGHT_INDEX
]));
4086 /* Evaluate IT->font_height with `height' bound to the
4087 current specified height to get the new height. */
4088 int count
= SPECPDL_INDEX ();
4090 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4091 value
= safe_eval (it
->font_height
);
4092 unbind_to (count
, Qnil
);
4094 if (NUMBERP (value
))
4095 new_height
= XFLOATINT (value
);
4099 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4106 /* Handle `(space-width WIDTH)'. */
4108 && EQ (XCAR (spec
), Qspace_width
)
4109 && CONSP (XCDR (spec
)))
4113 if (!FRAME_WINDOW_P (it
->f
))
4116 value
= XCAR (XCDR (spec
));
4117 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4118 it
->space_width
= value
;
4124 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4126 && EQ (XCAR (spec
), Qslice
))
4132 if (!FRAME_WINDOW_P (it
->f
))
4135 if (tem
= XCDR (spec
), CONSP (tem
))
4137 it
->slice
.x
= XCAR (tem
);
4138 if (tem
= XCDR (tem
), CONSP (tem
))
4140 it
->slice
.y
= XCAR (tem
);
4141 if (tem
= XCDR (tem
), CONSP (tem
))
4143 it
->slice
.width
= XCAR (tem
);
4144 if (tem
= XCDR (tem
), CONSP (tem
))
4145 it
->slice
.height
= XCAR (tem
);
4154 /* Handle `(raise FACTOR)'. */
4156 && EQ (XCAR (spec
), Qraise
)
4157 && CONSP (XCDR (spec
)))
4161 if (!FRAME_WINDOW_P (it
->f
))
4164 #ifdef HAVE_WINDOW_SYSTEM
4165 value
= XCAR (XCDR (spec
));
4166 if (NUMBERP (value
))
4168 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4169 it
->voffset
= - (XFLOATINT (value
)
4170 * (FONT_HEIGHT (face
->font
)));
4172 #endif /* HAVE_WINDOW_SYSTEM */
4178 /* Don't handle the other kinds of display specifications
4179 inside a string that we got from a `display' property. */
4180 if (it
&& it
->string_from_display_prop_p
)
4183 /* Characters having this form of property are not displayed, so
4184 we have to find the end of the property. */
4187 start_pos
= *position
;
4188 *position
= display_prop_end (it
, object
, start_pos
);
4192 /* Stop the scan at that end position--we assume that all
4193 text properties change there. */
4195 it
->stop_charpos
= position
->charpos
;
4197 /* Handle `(left-fringe BITMAP [FACE])'
4198 and `(right-fringe BITMAP [FACE])'. */
4200 && (EQ (XCAR (spec
), Qleft_fringe
)
4201 || EQ (XCAR (spec
), Qright_fringe
))
4202 && CONSP (XCDR (spec
)))
4208 if (!FRAME_WINDOW_P (it
->f
))
4209 /* If we return here, POSITION has been advanced
4210 across the text with this property. */
4213 else if (!frame_window_p
)
4216 #ifdef HAVE_WINDOW_SYSTEM
4217 value
= XCAR (XCDR (spec
));
4218 if (!SYMBOLP (value
)
4219 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
4220 /* If we return here, POSITION has been advanced
4221 across the text with this property. */
4226 int face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);;
4228 if (CONSP (XCDR (XCDR (spec
))))
4230 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
4231 int face_id2
= lookup_derived_face (it
->f
, face_name
,
4237 /* Save current settings of IT so that we can restore them
4238 when we are finished with the glyph property value. */
4239 push_it (it
, position
);
4241 it
->area
= TEXT_AREA
;
4242 it
->what
= IT_IMAGE
;
4243 it
->image_id
= -1; /* no image */
4244 it
->position
= start_pos
;
4245 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4246 it
->method
= GET_FROM_IMAGE
;
4247 it
->from_overlay
= Qnil
;
4248 it
->face_id
= face_id
;
4250 /* Say that we haven't consumed the characters with
4251 `display' property yet. The call to pop_it in
4252 set_iterator_to_next will clean this up. */
4253 *position
= start_pos
;
4255 if (EQ (XCAR (spec
), Qleft_fringe
))
4257 it
->left_user_fringe_bitmap
= fringe_bitmap
;
4258 it
->left_user_fringe_face_id
= face_id
;
4262 it
->right_user_fringe_bitmap
= fringe_bitmap
;
4263 it
->right_user_fringe_face_id
= face_id
;
4266 #endif /* HAVE_WINDOW_SYSTEM */
4270 /* Prepare to handle `((margin left-margin) ...)',
4271 `((margin right-margin) ...)' and `((margin nil) ...)'
4272 prefixes for display specifications. */
4273 location
= Qunbound
;
4274 if (CONSP (spec
) && CONSP (XCAR (spec
)))
4278 value
= XCDR (spec
);
4280 value
= XCAR (value
);
4283 if (EQ (XCAR (tem
), Qmargin
)
4284 && (tem
= XCDR (tem
),
4285 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
4287 || EQ (tem
, Qleft_margin
)
4288 || EQ (tem
, Qright_margin
))))
4292 if (EQ (location
, Qunbound
))
4298 /* After this point, VALUE is the property after any
4299 margin prefix has been stripped. It must be a string,
4300 an image specification, or `(space ...)'.
4302 LOCATION specifies where to display: `left-margin',
4303 `right-margin' or nil. */
4305 valid_p
= (STRINGP (value
)
4306 #ifdef HAVE_WINDOW_SYSTEM
4307 || ((it
? FRAME_WINDOW_P (it
->f
) : frame_window_p
)
4308 && valid_image_p (value
))
4309 #endif /* not HAVE_WINDOW_SYSTEM */
4310 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
4312 if (valid_p
&& !display_replaced_p
)
4317 /* Save current settings of IT so that we can restore them
4318 when we are finished with the glyph property value. */
4319 push_it (it
, position
);
4320 it
->from_overlay
= overlay
;
4322 if (NILP (location
))
4323 it
->area
= TEXT_AREA
;
4324 else if (EQ (location
, Qleft_margin
))
4325 it
->area
= LEFT_MARGIN_AREA
;
4327 it
->area
= RIGHT_MARGIN_AREA
;
4329 if (STRINGP (value
))
4332 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4333 it
->current
.overlay_string_index
= -1;
4334 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4335 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
4336 it
->method
= GET_FROM_STRING
;
4337 it
->stop_charpos
= 0;
4338 it
->string_from_display_prop_p
= 1;
4339 /* Say that we haven't consumed the characters with
4340 `display' property yet. The call to pop_it in
4341 set_iterator_to_next will clean this up. */
4342 if (BUFFERP (object
))
4343 *position
= start_pos
;
4345 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
4347 it
->method
= GET_FROM_STRETCH
;
4349 *position
= it
->position
= start_pos
;
4351 #ifdef HAVE_WINDOW_SYSTEM
4354 it
->what
= IT_IMAGE
;
4355 it
->image_id
= lookup_image (it
->f
, value
);
4356 it
->position
= start_pos
;
4357 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4358 it
->method
= GET_FROM_IMAGE
;
4360 /* Say that we haven't consumed the characters with
4361 `display' property yet. The call to pop_it in
4362 set_iterator_to_next will clean this up. */
4363 *position
= start_pos
;
4365 #endif /* HAVE_WINDOW_SYSTEM */
4370 /* Invalid property or property not supported. Restore
4371 POSITION to what it was before. */
4372 *position
= start_pos
;
4376 /* Check if PROP is a display property value whose text should be
4377 treated as intangible. OVERLAY is the overlay from which PROP
4378 came, or nil if it came from a text property. CHARPOS and BYTEPOS
4379 specify the buffer position covered by PROP. */
4382 display_prop_intangible_p (Lisp_Object prop
, Lisp_Object overlay
,
4383 EMACS_INT charpos
, EMACS_INT bytepos
)
4385 int frame_window_p
= FRAME_WINDOW_P (XFRAME (selected_frame
));
4386 struct text_pos position
;
4388 SET_TEXT_POS (position
, charpos
, bytepos
);
4389 return handle_display_spec (NULL
, prop
, Qnil
, overlay
,
4390 &position
, charpos
, frame_window_p
);
4394 /* Return 1 if PROP is a display sub-property value containing STRING.
4396 Implementation note: this and the following function are really
4397 special cases of handle_display_spec and
4398 handle_single_display_spec, and should ideally use the same code.
4399 Until they do, these two pairs must be consistent and must be
4400 modified in sync. */
4403 single_display_spec_string_p (Lisp_Object prop
, Lisp_Object string
)
4405 if (EQ (string
, prop
))
4408 /* Skip over `when FORM'. */
4409 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
4414 /* Actually, the condition following `when' should be eval'ed,
4415 like handle_single_display_spec does, and we should return
4416 zero if it evaluates to nil. However, this function is
4417 called only when the buffer was already displayed and some
4418 glyph in the glyph matrix was found to come from a display
4419 string. Therefore, the condition was already evaluated, and
4420 the result was non-nil, otherwise the display string wouldn't
4421 have been displayed and we would have never been called for
4422 this property. Thus, we can skip the evaluation and assume
4423 its result is non-nil. */
4428 /* Skip over `margin LOCATION'. */
4429 if (EQ (XCAR (prop
), Qmargin
))
4440 return EQ (prop
, string
) || (CONSP (prop
) && EQ (XCAR (prop
), string
));
4444 /* Return 1 if STRING appears in the `display' property PROP. */
4447 display_prop_string_p (Lisp_Object prop
, Lisp_Object string
)
4450 && !EQ (XCAR (prop
), Qwhen
)
4451 && !(CONSP (XCAR (prop
)) && EQ (Qmargin
, XCAR (XCAR (prop
)))))
4453 /* A list of sub-properties. */
4454 while (CONSP (prop
))
4456 if (single_display_spec_string_p (XCAR (prop
), string
))
4461 else if (VECTORP (prop
))
4463 /* A vector of sub-properties. */
4465 for (i
= 0; i
< ASIZE (prop
); ++i
)
4466 if (single_display_spec_string_p (AREF (prop
, i
), string
))
4470 return single_display_spec_string_p (prop
, string
);
4475 /* Look for STRING in overlays and text properties in the current
4476 buffer, between character positions FROM and TO (excluding TO).
4477 BACK_P non-zero means look back (in this case, TO is supposed to be
4479 Value is the first character position where STRING was found, or
4480 zero if it wasn't found before hitting TO.
4482 This function may only use code that doesn't eval because it is
4483 called asynchronously from note_mouse_highlight. */
4486 string_buffer_position_lim (Lisp_Object string
,
4487 EMACS_INT from
, EMACS_INT to
, int back_p
)
4489 Lisp_Object limit
, prop
, pos
;
4492 pos
= make_number (from
);
4494 if (!back_p
) /* looking forward */
4496 limit
= make_number (min (to
, ZV
));
4497 while (!found
&& !EQ (pos
, limit
))
4499 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4500 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4503 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
,
4507 else /* looking back */
4509 limit
= make_number (max (to
, BEGV
));
4510 while (!found
&& !EQ (pos
, limit
))
4512 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4513 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4516 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
4521 return found
? XINT (pos
) : 0;
4524 /* Determine which buffer position in current buffer STRING comes from.
4525 AROUND_CHARPOS is an approximate position where it could come from.
4526 Value is the buffer position or 0 if it couldn't be determined.
4528 This function is necessary because we don't record buffer positions
4529 in glyphs generated from strings (to keep struct glyph small).
4530 This function may only use code that doesn't eval because it is
4531 called asynchronously from note_mouse_highlight. */
4534 string_buffer_position (Lisp_Object string
, EMACS_INT around_charpos
)
4536 const int MAX_DISTANCE
= 1000;
4537 EMACS_INT found
= string_buffer_position_lim (string
, around_charpos
,
4538 around_charpos
+ MAX_DISTANCE
,
4542 found
= string_buffer_position_lim (string
, around_charpos
,
4543 around_charpos
- MAX_DISTANCE
, 1);
4549 /***********************************************************************
4550 `composition' property
4551 ***********************************************************************/
4553 /* Set up iterator IT from `composition' property at its current
4554 position. Called from handle_stop. */
4556 static enum prop_handled
4557 handle_composition_prop (struct it
*it
)
4559 Lisp_Object prop
, string
;
4560 EMACS_INT pos
, pos_byte
, start
, end
;
4562 if (STRINGP (it
->string
))
4566 pos
= IT_STRING_CHARPOS (*it
);
4567 pos_byte
= IT_STRING_BYTEPOS (*it
);
4568 string
= it
->string
;
4569 s
= SDATA (string
) + pos_byte
;
4570 it
->c
= STRING_CHAR (s
);
4574 pos
= IT_CHARPOS (*it
);
4575 pos_byte
= IT_BYTEPOS (*it
);
4577 it
->c
= FETCH_CHAR (pos_byte
);
4580 /* If there's a valid composition and point is not inside of the
4581 composition (in the case that the composition is from the current
4582 buffer), draw a glyph composed from the composition components. */
4583 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
4584 && COMPOSITION_VALID_P (start
, end
, prop
)
4585 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
4589 if (STRINGP (it
->string
))
4590 pos_byte
= string_char_to_byte (it
->string
, start
);
4592 pos_byte
= CHAR_TO_BYTE (start
);
4594 it
->cmp_it
.id
= get_composition_id (start
, pos_byte
, end
- start
,
4597 if (it
->cmp_it
.id
>= 0)
4600 it
->cmp_it
.nchars
= COMPOSITION_LENGTH (prop
);
4601 it
->cmp_it
.nglyphs
= -1;
4605 return HANDLED_NORMALLY
;
4610 /***********************************************************************
4612 ***********************************************************************/
4614 /* The following structure is used to record overlay strings for
4615 later sorting in load_overlay_strings. */
4617 struct overlay_entry
4619 Lisp_Object overlay
;
4626 /* Set up iterator IT from overlay strings at its current position.
4627 Called from handle_stop. */
4629 static enum prop_handled
4630 handle_overlay_change (struct it
*it
)
4632 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
4633 return HANDLED_RECOMPUTE_PROPS
;
4635 return HANDLED_NORMALLY
;
4639 /* Set up the next overlay string for delivery by IT, if there is an
4640 overlay string to deliver. Called by set_iterator_to_next when the
4641 end of the current overlay string is reached. If there are more
4642 overlay strings to display, IT->string and
4643 IT->current.overlay_string_index are set appropriately here.
4644 Otherwise IT->string is set to nil. */
4647 next_overlay_string (struct it
*it
)
4649 ++it
->current
.overlay_string_index
;
4650 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
4652 /* No more overlay strings. Restore IT's settings to what
4653 they were before overlay strings were processed, and
4654 continue to deliver from current_buffer. */
4656 it
->ellipsis_p
= (it
->stack
[it
->sp
- 1].display_ellipsis_p
!= 0);
4659 || (NILP (it
->string
)
4660 && it
->method
== GET_FROM_BUFFER
4661 && it
->stop_charpos
>= BEGV
4662 && it
->stop_charpos
<= it
->end_charpos
));
4663 it
->current
.overlay_string_index
= -1;
4664 it
->n_overlay_strings
= 0;
4665 it
->overlay_strings_charpos
= -1;
4667 /* If we're at the end of the buffer, record that we have
4668 processed the overlay strings there already, so that
4669 next_element_from_buffer doesn't try it again. */
4670 if (NILP (it
->string
) && IT_CHARPOS (*it
) >= it
->end_charpos
)
4671 it
->overlay_strings_at_end_processed_p
= 1;
4675 /* There are more overlay strings to process. If
4676 IT->current.overlay_string_index has advanced to a position
4677 where we must load IT->overlay_strings with more strings, do
4678 it. We must load at the IT->overlay_strings_charpos where
4679 IT->n_overlay_strings was originally computed; when invisible
4680 text is present, this might not be IT_CHARPOS (Bug#7016). */
4681 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
4683 if (it
->current
.overlay_string_index
&& i
== 0)
4684 load_overlay_strings (it
, it
->overlay_strings_charpos
);
4686 /* Initialize IT to deliver display elements from the overlay
4688 it
->string
= it
->overlay_strings
[i
];
4689 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4690 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
4691 it
->method
= GET_FROM_STRING
;
4692 it
->stop_charpos
= 0;
4693 if (it
->cmp_it
.stop_pos
>= 0)
4694 it
->cmp_it
.stop_pos
= 0;
4701 /* Compare two overlay_entry structures E1 and E2. Used as a
4702 comparison function for qsort in load_overlay_strings. Overlay
4703 strings for the same position are sorted so that
4705 1. All after-strings come in front of before-strings, except
4706 when they come from the same overlay.
4708 2. Within after-strings, strings are sorted so that overlay strings
4709 from overlays with higher priorities come first.
4711 2. Within before-strings, strings are sorted so that overlay
4712 strings from overlays with higher priorities come last.
4714 Value is analogous to strcmp. */
4718 compare_overlay_entries (const void *e1
, const void *e2
)
4720 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
4721 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
4724 if (entry1
->after_string_p
!= entry2
->after_string_p
)
4726 /* Let after-strings appear in front of before-strings if
4727 they come from different overlays. */
4728 if (EQ (entry1
->overlay
, entry2
->overlay
))
4729 result
= entry1
->after_string_p
? 1 : -1;
4731 result
= entry1
->after_string_p
? -1 : 1;
4733 else if (entry1
->after_string_p
)
4734 /* After-strings sorted in order of decreasing priority. */
4735 result
= entry2
->priority
- entry1
->priority
;
4737 /* Before-strings sorted in order of increasing priority. */
4738 result
= entry1
->priority
- entry2
->priority
;
4744 /* Load the vector IT->overlay_strings with overlay strings from IT's
4745 current buffer position, or from CHARPOS if that is > 0. Set
4746 IT->n_overlays to the total number of overlay strings found.
4748 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
4749 a time. On entry into load_overlay_strings,
4750 IT->current.overlay_string_index gives the number of overlay
4751 strings that have already been loaded by previous calls to this
4754 IT->add_overlay_start contains an additional overlay start
4755 position to consider for taking overlay strings from, if non-zero.
4756 This position comes into play when the overlay has an `invisible'
4757 property, and both before and after-strings. When we've skipped to
4758 the end of the overlay, because of its `invisible' property, we
4759 nevertheless want its before-string to appear.
4760 IT->add_overlay_start will contain the overlay start position
4763 Overlay strings are sorted so that after-string strings come in
4764 front of before-string strings. Within before and after-strings,
4765 strings are sorted by overlay priority. See also function
4766 compare_overlay_entries. */
4769 load_overlay_strings (struct it
*it
, EMACS_INT charpos
)
4771 Lisp_Object overlay
, window
, str
, invisible
;
4772 struct Lisp_Overlay
*ov
;
4773 EMACS_INT start
, end
;
4775 int n
= 0, i
, j
, invis_p
;
4776 struct overlay_entry
*entries
4777 = (struct overlay_entry
*) alloca (size
* sizeof *entries
);
4780 charpos
= IT_CHARPOS (*it
);
4782 /* Append the overlay string STRING of overlay OVERLAY to vector
4783 `entries' which has size `size' and currently contains `n'
4784 elements. AFTER_P non-zero means STRING is an after-string of
4786 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
4789 Lisp_Object priority; \
4793 int new_size = 2 * size; \
4794 struct overlay_entry *old = entries; \
4796 (struct overlay_entry *) alloca (new_size \
4797 * sizeof *entries); \
4798 memcpy (entries, old, size * sizeof *entries); \
4802 entries[n].string = (STRING); \
4803 entries[n].overlay = (OVERLAY); \
4804 priority = Foverlay_get ((OVERLAY), Qpriority); \
4805 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
4806 entries[n].after_string_p = (AFTER_P); \
4811 /* Process overlay before the overlay center. */
4812 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
4814 XSETMISC (overlay
, ov
);
4815 xassert (OVERLAYP (overlay
));
4816 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4817 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4822 /* Skip this overlay if it doesn't start or end at IT's current
4824 if (end
!= charpos
&& start
!= charpos
)
4827 /* Skip this overlay if it doesn't apply to IT->w. */
4828 window
= Foverlay_get (overlay
, Qwindow
);
4829 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
4832 /* If the text ``under'' the overlay is invisible, both before-
4833 and after-strings from this overlay are visible; start and
4834 end position are indistinguishable. */
4835 invisible
= Foverlay_get (overlay
, Qinvisible
);
4836 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
4838 /* If overlay has a non-empty before-string, record it. */
4839 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
4840 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
4842 RECORD_OVERLAY_STRING (overlay
, str
, 0);
4844 /* If overlay has a non-empty after-string, record it. */
4845 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
4846 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
4848 RECORD_OVERLAY_STRING (overlay
, str
, 1);
4851 /* Process overlays after the overlay center. */
4852 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
4854 XSETMISC (overlay
, ov
);
4855 xassert (OVERLAYP (overlay
));
4856 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4857 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4859 if (start
> charpos
)
4862 /* Skip this overlay if it doesn't start or end at IT's current
4864 if (end
!= charpos
&& start
!= charpos
)
4867 /* Skip this overlay if it doesn't apply to IT->w. */
4868 window
= Foverlay_get (overlay
, Qwindow
);
4869 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
4872 /* If the text ``under'' the overlay is invisible, it has a zero
4873 dimension, and both before- and after-strings apply. */
4874 invisible
= Foverlay_get (overlay
, Qinvisible
);
4875 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
4877 /* If overlay has a non-empty before-string, record it. */
4878 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
4879 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
4881 RECORD_OVERLAY_STRING (overlay
, str
, 0);
4883 /* If overlay has a non-empty after-string, record it. */
4884 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
4885 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
4887 RECORD_OVERLAY_STRING (overlay
, str
, 1);
4890 #undef RECORD_OVERLAY_STRING
4894 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
4896 /* Record number of overlay strings, and where we computed it. */
4897 it
->n_overlay_strings
= n
;
4898 it
->overlay_strings_charpos
= charpos
;
4900 /* IT->current.overlay_string_index is the number of overlay strings
4901 that have already been consumed by IT. Copy some of the
4902 remaining overlay strings to IT->overlay_strings. */
4904 j
= it
->current
.overlay_string_index
;
4905 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
4907 it
->overlay_strings
[i
] = entries
[j
].string
;
4908 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
4915 /* Get the first chunk of overlay strings at IT's current buffer
4916 position, or at CHARPOS if that is > 0. Value is non-zero if at
4917 least one overlay string was found. */
4920 get_overlay_strings_1 (struct it
*it
, EMACS_INT charpos
, int compute_stop_p
)
4922 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
4923 process. This fills IT->overlay_strings with strings, and sets
4924 IT->n_overlay_strings to the total number of strings to process.
4925 IT->pos.overlay_string_index has to be set temporarily to zero
4926 because load_overlay_strings needs this; it must be set to -1
4927 when no overlay strings are found because a zero value would
4928 indicate a position in the first overlay string. */
4929 it
->current
.overlay_string_index
= 0;
4930 load_overlay_strings (it
, charpos
);
4932 /* If we found overlay strings, set up IT to deliver display
4933 elements from the first one. Otherwise set up IT to deliver
4934 from current_buffer. */
4935 if (it
->n_overlay_strings
)
4937 /* Make sure we know settings in current_buffer, so that we can
4938 restore meaningful values when we're done with the overlay
4941 compute_stop_pos (it
);
4942 xassert (it
->face_id
>= 0);
4944 /* Save IT's settings. They are restored after all overlay
4945 strings have been processed. */
4946 xassert (!compute_stop_p
|| it
->sp
== 0);
4948 /* When called from handle_stop, there might be an empty display
4949 string loaded. In that case, don't bother saving it. */
4950 if (!STRINGP (it
->string
) || SCHARS (it
->string
))
4953 /* Set up IT to deliver display elements from the first overlay
4955 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4956 it
->string
= it
->overlay_strings
[0];
4957 it
->from_overlay
= Qnil
;
4958 it
->stop_charpos
= 0;
4959 xassert (STRINGP (it
->string
));
4960 it
->end_charpos
= SCHARS (it
->string
);
4961 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4962 it
->method
= GET_FROM_STRING
;
4966 it
->current
.overlay_string_index
= -1;
4971 get_overlay_strings (struct it
*it
, EMACS_INT charpos
)
4974 it
->method
= GET_FROM_BUFFER
;
4976 (void) get_overlay_strings_1 (it
, charpos
, 1);
4980 /* Value is non-zero if we found at least one overlay string. */
4981 return STRINGP (it
->string
);
4986 /***********************************************************************
4987 Saving and restoring state
4988 ***********************************************************************/
4990 /* Save current settings of IT on IT->stack. Called, for example,
4991 before setting up IT for an overlay string, to be able to restore
4992 IT's settings to what they were after the overlay string has been
4993 processed. If POSITION is non-NULL, it is the position to save on
4994 the stack instead of IT->position. */
4997 push_it (struct it
*it
, struct text_pos
*position
)
4999 struct iterator_stack_entry
*p
;
5001 xassert (it
->sp
< IT_STACK_SIZE
);
5002 p
= it
->stack
+ it
->sp
;
5004 p
->stop_charpos
= it
->stop_charpos
;
5005 p
->prev_stop
= it
->prev_stop
;
5006 p
->base_level_stop
= it
->base_level_stop
;
5007 p
->cmp_it
= it
->cmp_it
;
5008 xassert (it
->face_id
>= 0);
5009 p
->face_id
= it
->face_id
;
5010 p
->string
= it
->string
;
5011 p
->method
= it
->method
;
5012 p
->from_overlay
= it
->from_overlay
;
5015 case GET_FROM_IMAGE
:
5016 p
->u
.image
.object
= it
->object
;
5017 p
->u
.image
.image_id
= it
->image_id
;
5018 p
->u
.image
.slice
= it
->slice
;
5020 case GET_FROM_STRETCH
:
5021 p
->u
.stretch
.object
= it
->object
;
5024 p
->position
= position
? *position
: it
->position
;
5025 p
->current
= it
->current
;
5026 p
->end_charpos
= it
->end_charpos
;
5027 p
->string_nchars
= it
->string_nchars
;
5029 p
->multibyte_p
= it
->multibyte_p
;
5030 p
->avoid_cursor_p
= it
->avoid_cursor_p
;
5031 p
->space_width
= it
->space_width
;
5032 p
->font_height
= it
->font_height
;
5033 p
->voffset
= it
->voffset
;
5034 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5035 p
->display_ellipsis_p
= 0;
5036 p
->line_wrap
= it
->line_wrap
;
5041 iterate_out_of_display_property (struct it
*it
)
5043 /* Maybe initialize paragraph direction. If we are at the beginning
5044 of a new paragraph, next_element_from_buffer may not have a
5045 chance to do that. */
5046 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
5047 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
5048 /* prev_stop can be zero, so check against BEGV as well. */
5049 while (it
->bidi_it
.charpos
>= BEGV
5050 && it
->prev_stop
<= it
->bidi_it
.charpos
5051 && it
->bidi_it
.charpos
< CHARPOS (it
->position
))
5052 bidi_move_to_visually_next (&it
->bidi_it
);
5053 /* Record the stop_pos we just crossed, for when we cross it
5055 if (it
->bidi_it
.charpos
> CHARPOS (it
->position
))
5056 it
->prev_stop
= CHARPOS (it
->position
);
5057 /* If we ended up not where pop_it put us, resync IT's
5058 positional members with the bidi iterator. */
5059 if (it
->bidi_it
.charpos
!= CHARPOS (it
->position
))
5061 SET_TEXT_POS (it
->position
,
5062 it
->bidi_it
.charpos
, it
->bidi_it
.bytepos
);
5063 it
->current
.pos
= it
->position
;
5067 /* Restore IT's settings from IT->stack. Called, for example, when no
5068 more overlay strings must be processed, and we return to delivering
5069 display elements from a buffer, or when the end of a string from a
5070 `display' property is reached and we return to delivering display
5071 elements from an overlay string, or from a buffer. */
5074 pop_it (struct it
*it
)
5076 struct iterator_stack_entry
*p
;
5078 xassert (it
->sp
> 0);
5080 p
= it
->stack
+ it
->sp
;
5081 it
->stop_charpos
= p
->stop_charpos
;
5082 it
->prev_stop
= p
->prev_stop
;
5083 it
->base_level_stop
= p
->base_level_stop
;
5084 it
->cmp_it
= p
->cmp_it
;
5085 it
->face_id
= p
->face_id
;
5086 it
->current
= p
->current
;
5087 it
->position
= p
->position
;
5088 it
->string
= p
->string
;
5089 it
->from_overlay
= p
->from_overlay
;
5090 if (NILP (it
->string
))
5091 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
5092 it
->method
= p
->method
;
5095 case GET_FROM_IMAGE
:
5096 it
->image_id
= p
->u
.image
.image_id
;
5097 it
->object
= p
->u
.image
.object
;
5098 it
->slice
= p
->u
.image
.slice
;
5100 case GET_FROM_STRETCH
:
5101 it
->object
= p
->u
.comp
.object
;
5103 case GET_FROM_BUFFER
:
5104 it
->object
= it
->w
->buffer
;
5107 /* Bidi-iterate until we get out of the portion of text, if
5108 any, covered by a `display' text property or an overlay
5109 with `display' property. (We cannot just jump there,
5110 because the internal coherency of the bidi iterator state
5111 can not be preserved across such jumps.) We also must
5112 determine the paragraph base direction if the overlay we
5113 just processed is at the beginning of a new
5115 iterate_out_of_display_property (it
);
5118 case GET_FROM_STRING
:
5119 it
->object
= it
->string
;
5121 case GET_FROM_DISPLAY_VECTOR
:
5123 it
->method
= GET_FROM_C_STRING
;
5124 else if (STRINGP (it
->string
))
5125 it
->method
= GET_FROM_STRING
;
5128 it
->method
= GET_FROM_BUFFER
;
5129 it
->object
= it
->w
->buffer
;
5132 it
->end_charpos
= p
->end_charpos
;
5133 it
->string_nchars
= p
->string_nchars
;
5135 it
->multibyte_p
= p
->multibyte_p
;
5136 it
->avoid_cursor_p
= p
->avoid_cursor_p
;
5137 it
->space_width
= p
->space_width
;
5138 it
->font_height
= p
->font_height
;
5139 it
->voffset
= p
->voffset
;
5140 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
5141 it
->line_wrap
= p
->line_wrap
;
5146 /***********************************************************************
5148 ***********************************************************************/
5150 /* Set IT's current position to the previous line start. */
5153 back_to_previous_line_start (struct it
*it
)
5155 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
5156 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
5160 /* Move IT to the next line start.
5162 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5163 we skipped over part of the text (as opposed to moving the iterator
5164 continuously over the text). Otherwise, don't change the value
5167 Newlines may come from buffer text, overlay strings, or strings
5168 displayed via the `display' property. That's the reason we can't
5169 simply use find_next_newline_no_quit.
5171 Note that this function may not skip over invisible text that is so
5172 because of text properties and immediately follows a newline. If
5173 it would, function reseat_at_next_visible_line_start, when called
5174 from set_iterator_to_next, would effectively make invisible
5175 characters following a newline part of the wrong glyph row, which
5176 leads to wrong cursor motion. */
5179 forward_to_next_line_start (struct it
*it
, int *skipped_p
)
5181 int old_selective
, newline_found_p
, n
;
5182 const int MAX_NEWLINE_DISTANCE
= 500;
5184 /* If already on a newline, just consume it to avoid unintended
5185 skipping over invisible text below. */
5186 if (it
->what
== IT_CHARACTER
5188 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
5190 set_iterator_to_next (it
, 0);
5195 /* Don't handle selective display in the following. It's (a)
5196 unnecessary because it's done by the caller, and (b) leads to an
5197 infinite recursion because next_element_from_ellipsis indirectly
5198 calls this function. */
5199 old_selective
= it
->selective
;
5202 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5203 from buffer text. */
5204 for (n
= newline_found_p
= 0;
5205 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
5206 n
+= STRINGP (it
->string
) ? 0 : 1)
5208 if (!get_next_display_element (it
))
5210 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
5211 set_iterator_to_next (it
, 0);
5214 /* If we didn't find a newline near enough, see if we can use a
5216 if (!newline_found_p
)
5218 EMACS_INT start
= IT_CHARPOS (*it
);
5219 EMACS_INT limit
= find_next_newline_no_quit (start
, 1);
5222 xassert (!STRINGP (it
->string
));
5224 /* If there isn't any `display' property in sight, and no
5225 overlays, we can just use the position of the newline in
5227 if (it
->stop_charpos
>= limit
5228 || ((pos
= Fnext_single_property_change (make_number (start
),
5230 Qnil
, make_number (limit
)),
5232 && next_overlay_change (start
) == ZV
))
5234 IT_CHARPOS (*it
) = limit
;
5235 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
5236 *skipped_p
= newline_found_p
= 1;
5240 while (get_next_display_element (it
)
5241 && !newline_found_p
)
5243 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
5244 set_iterator_to_next (it
, 0);
5249 it
->selective
= old_selective
;
5250 return newline_found_p
;
5254 /* Set IT's current position to the previous visible line start. Skip
5255 invisible text that is so either due to text properties or due to
5256 selective display. Caution: this does not change IT->current_x and
5260 back_to_previous_visible_line_start (struct it
*it
)
5262 while (IT_CHARPOS (*it
) > BEGV
)
5264 back_to_previous_line_start (it
);
5266 if (IT_CHARPOS (*it
) <= BEGV
)
5269 /* If selective > 0, then lines indented more than its value are
5271 if (it
->selective
> 0
5272 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5273 (double) it
->selective
)) /* iftc */
5276 /* Check the newline before point for invisibility. */
5279 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
5280 Qinvisible
, it
->window
);
5281 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
5285 if (IT_CHARPOS (*it
) <= BEGV
)
5292 Lisp_Object val
, overlay
;
5294 /* If newline is part of a composition, continue from start of composition */
5295 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
5296 && beg
< IT_CHARPOS (*it
))
5299 /* If newline is replaced by a display property, find start of overlay
5300 or interval and continue search from that point. */
5302 pos
= --IT_CHARPOS (it2
);
5305 it2
.string_from_display_prop_p
= 0;
5306 if (handle_display_prop (&it2
) == HANDLED_RETURN
5307 && !NILP (val
= get_char_property_and_overlay
5308 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
5309 && (OVERLAYP (overlay
)
5310 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
5311 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
5314 /* Newline is not replaced by anything -- so we are done. */
5320 IT_CHARPOS (*it
) = beg
;
5321 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
5325 it
->continuation_lines_width
= 0;
5327 xassert (IT_CHARPOS (*it
) >= BEGV
);
5328 xassert (IT_CHARPOS (*it
) == BEGV
5329 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5334 /* Reseat iterator IT at the previous visible line start. Skip
5335 invisible text that is so either due to text properties or due to
5336 selective display. At the end, update IT's overlay information,
5337 face information etc. */
5340 reseat_at_previous_visible_line_start (struct it
*it
)
5342 back_to_previous_visible_line_start (it
);
5343 reseat (it
, it
->current
.pos
, 1);
5348 /* Reseat iterator IT on the next visible line start in the current
5349 buffer. ON_NEWLINE_P non-zero means position IT on the newline
5350 preceding the line start. Skip over invisible text that is so
5351 because of selective display. Compute faces, overlays etc at the
5352 new position. Note that this function does not skip over text that
5353 is invisible because of text properties. */
5356 reseat_at_next_visible_line_start (struct it
*it
, int on_newline_p
)
5358 int newline_found_p
, skipped_p
= 0;
5360 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5362 /* Skip over lines that are invisible because they are indented
5363 more than the value of IT->selective. */
5364 if (it
->selective
> 0)
5365 while (IT_CHARPOS (*it
) < ZV
5366 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5367 (double) it
->selective
)) /* iftc */
5369 xassert (IT_BYTEPOS (*it
) == BEGV
5370 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5371 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5374 /* Position on the newline if that's what's requested. */
5375 if (on_newline_p
&& newline_found_p
)
5377 if (STRINGP (it
->string
))
5379 if (IT_STRING_CHARPOS (*it
) > 0)
5381 --IT_STRING_CHARPOS (*it
);
5382 --IT_STRING_BYTEPOS (*it
);
5385 else if (IT_CHARPOS (*it
) > BEGV
)
5389 reseat (it
, it
->current
.pos
, 0);
5393 reseat (it
, it
->current
.pos
, 0);
5400 /***********************************************************************
5401 Changing an iterator's position
5402 ***********************************************************************/
5404 /* Change IT's current position to POS in current_buffer. If FORCE_P
5405 is non-zero, always check for text properties at the new position.
5406 Otherwise, text properties are only looked up if POS >=
5407 IT->check_charpos of a property. */
5410 reseat (struct it
*it
, struct text_pos pos
, int force_p
)
5412 EMACS_INT original_pos
= IT_CHARPOS (*it
);
5414 reseat_1 (it
, pos
, 0);
5416 /* Determine where to check text properties. Avoid doing it
5417 where possible because text property lookup is very expensive. */
5419 || CHARPOS (pos
) > it
->stop_charpos
5420 || CHARPOS (pos
) < original_pos
)
5424 /* For bidi iteration, we need to prime prev_stop and
5425 base_level_stop with our best estimations. */
5426 if (CHARPOS (pos
) < it
->prev_stop
)
5428 handle_stop_backwards (it
, BEGV
);
5429 if (CHARPOS (pos
) < it
->base_level_stop
)
5430 it
->base_level_stop
= 0;
5432 else if (CHARPOS (pos
) > it
->stop_charpos
5433 && it
->stop_charpos
>= BEGV
)
5434 handle_stop_backwards (it
, it
->stop_charpos
);
5441 it
->prev_stop
= it
->base_level_stop
= 0;
5450 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
5451 IT->stop_pos to POS, also. */
5454 reseat_1 (struct it
*it
, struct text_pos pos
, int set_stop_p
)
5456 /* Don't call this function when scanning a C string. */
5457 xassert (it
->s
== NULL
);
5459 /* POS must be a reasonable value. */
5460 xassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
5462 it
->current
.pos
= it
->position
= pos
;
5463 it
->end_charpos
= ZV
;
5465 it
->current
.dpvec_index
= -1;
5466 it
->current
.overlay_string_index
= -1;
5467 IT_STRING_CHARPOS (*it
) = -1;
5468 IT_STRING_BYTEPOS (*it
) = -1;
5470 it
->string_from_display_prop_p
= 0;
5471 it
->method
= GET_FROM_BUFFER
;
5472 it
->object
= it
->w
->buffer
;
5473 it
->area
= TEXT_AREA
;
5474 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
5476 it
->string_from_display_prop_p
= 0;
5477 it
->face_before_selective_p
= 0;
5480 it
->bidi_it
.first_elt
= 1;
5481 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
5482 it
->bidi_it
.disp_pos
= -1;
5487 it
->stop_charpos
= CHARPOS (pos
);
5488 it
->base_level_stop
= CHARPOS (pos
);
5493 /* Set up IT for displaying a string, starting at CHARPOS in window W.
5494 If S is non-null, it is a C string to iterate over. Otherwise,
5495 STRING gives a Lisp string to iterate over.
5497 If PRECISION > 0, don't return more then PRECISION number of
5498 characters from the string.
5500 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
5501 characters have been returned. FIELD_WIDTH < 0 means an infinite
5504 MULTIBYTE = 0 means disable processing of multibyte characters,
5505 MULTIBYTE > 0 means enable it,
5506 MULTIBYTE < 0 means use IT->multibyte_p.
5508 IT must be initialized via a prior call to init_iterator before
5509 calling this function. */
5512 reseat_to_string (struct it
*it
, const char *s
, Lisp_Object string
,
5513 EMACS_INT charpos
, EMACS_INT precision
, int field_width
,
5516 /* No region in strings. */
5517 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
5519 /* No text property checks performed by default, but see below. */
5520 it
->stop_charpos
= -1;
5522 /* Set iterator position and end position. */
5523 memset (&it
->current
, 0, sizeof it
->current
);
5524 it
->current
.overlay_string_index
= -1;
5525 it
->current
.dpvec_index
= -1;
5526 xassert (charpos
>= 0);
5528 /* If STRING is specified, use its multibyteness, otherwise use the
5529 setting of MULTIBYTE, if specified. */
5531 it
->multibyte_p
= multibyte
> 0;
5535 xassert (STRINGP (string
));
5536 it
->string
= string
;
5538 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
5539 it
->method
= GET_FROM_STRING
;
5540 it
->current
.string_pos
= string_pos (charpos
, string
);
5544 it
->s
= (const unsigned char *) s
;
5547 /* Note that we use IT->current.pos, not it->current.string_pos,
5548 for displaying C strings. */
5549 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
5550 if (it
->multibyte_p
)
5552 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
5553 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
5557 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
5558 it
->end_charpos
= it
->string_nchars
= strlen (s
);
5561 it
->method
= GET_FROM_C_STRING
;
5564 /* PRECISION > 0 means don't return more than PRECISION characters
5566 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
5567 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
5569 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
5570 characters have been returned. FIELD_WIDTH == 0 means don't pad,
5571 FIELD_WIDTH < 0 means infinite field width. This is useful for
5572 padding with `-' at the end of a mode line. */
5573 if (field_width
< 0)
5574 field_width
= INFINITY
;
5575 if (field_width
> it
->end_charpos
- charpos
)
5576 it
->end_charpos
= charpos
+ field_width
;
5578 /* Use the standard display table for displaying strings. */
5579 if (DISP_TABLE_P (Vstandard_display_table
))
5580 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
5582 it
->stop_charpos
= charpos
;
5583 if (s
== NULL
&& it
->multibyte_p
)
5585 EMACS_INT endpos
= SCHARS (it
->string
);
5586 if (endpos
> it
->end_charpos
)
5587 endpos
= it
->end_charpos
;
5588 composition_compute_stop_pos (&it
->cmp_it
, charpos
, -1, endpos
,
5596 /***********************************************************************
5598 ***********************************************************************/
5600 /* Map enum it_method value to corresponding next_element_from_* function. */
5602 static int (* get_next_element
[NUM_IT_METHODS
]) (struct it
*it
) =
5604 next_element_from_buffer
,
5605 next_element_from_display_vector
,
5606 next_element_from_string
,
5607 next_element_from_c_string
,
5608 next_element_from_image
,
5609 next_element_from_stretch
5612 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
5615 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
5616 (possibly with the following characters). */
5618 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
5619 ((IT)->cmp_it.id >= 0 \
5620 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
5621 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
5622 END_CHARPOS, (IT)->w, \
5623 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
5627 /* Lookup the char-table Vglyphless_char_display for character C (-1
5628 if we want information for no-font case), and return the display
5629 method symbol. By side-effect, update it->what and
5630 it->glyphless_method. This function is called from
5631 get_next_display_element for each character element, and from
5632 x_produce_glyphs when no suitable font was found. */
5635 lookup_glyphless_char_display (int c
, struct it
*it
)
5637 Lisp_Object glyphless_method
= Qnil
;
5639 if (CHAR_TABLE_P (Vglyphless_char_display
)
5640 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
)) >= 1)
5644 glyphless_method
= CHAR_TABLE_REF (Vglyphless_char_display
, c
);
5645 if (CONSP (glyphless_method
))
5646 glyphless_method
= FRAME_WINDOW_P (it
->f
)
5647 ? XCAR (glyphless_method
)
5648 : XCDR (glyphless_method
);
5651 glyphless_method
= XCHAR_TABLE (Vglyphless_char_display
)->extras
[0];
5655 if (NILP (glyphless_method
))
5658 /* The default is to display the character by a proper font. */
5660 /* The default for the no-font case is to display an empty box. */
5661 glyphless_method
= Qempty_box
;
5663 if (EQ (glyphless_method
, Qzero_width
))
5666 return glyphless_method
;
5667 /* This method can't be used for the no-font case. */
5668 glyphless_method
= Qempty_box
;
5670 if (EQ (glyphless_method
, Qthin_space
))
5671 it
->glyphless_method
= GLYPHLESS_DISPLAY_THIN_SPACE
;
5672 else if (EQ (glyphless_method
, Qempty_box
))
5673 it
->glyphless_method
= GLYPHLESS_DISPLAY_EMPTY_BOX
;
5674 else if (EQ (glyphless_method
, Qhex_code
))
5675 it
->glyphless_method
= GLYPHLESS_DISPLAY_HEX_CODE
;
5676 else if (STRINGP (glyphless_method
))
5677 it
->glyphless_method
= GLYPHLESS_DISPLAY_ACRONYM
;
5680 /* Invalid value. We use the default method. */
5681 glyphless_method
= Qnil
;
5684 it
->what
= IT_GLYPHLESS
;
5685 return glyphless_method
;
5688 /* Load IT's display element fields with information about the next
5689 display element from the current position of IT. Value is zero if
5690 end of buffer (or C string) is reached. */
5692 static struct frame
*last_escape_glyph_frame
= NULL
;
5693 static unsigned last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
5694 static int last_escape_glyph_merged_face_id
= 0;
5696 struct frame
*last_glyphless_glyph_frame
= NULL
;
5697 unsigned last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
5698 int last_glyphless_glyph_merged_face_id
= 0;
5701 get_next_display_element (struct it
*it
)
5703 /* Non-zero means that we found a display element. Zero means that
5704 we hit the end of what we iterate over. Performance note: the
5705 function pointer `method' used here turns out to be faster than
5706 using a sequence of if-statements. */
5710 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
5712 if (it
->what
== IT_CHARACTER
)
5714 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
5715 and only if (a) the resolved directionality of that character
5717 /* FIXME: Do we need an exception for characters from display
5719 if (it
->bidi_p
&& it
->bidi_it
.type
== STRONG_R
)
5720 it
->c
= bidi_mirror_char (it
->c
);
5721 /* Map via display table or translate control characters.
5722 IT->c, IT->len etc. have been set to the next character by
5723 the function call above. If we have a display table, and it
5724 contains an entry for IT->c, translate it. Don't do this if
5725 IT->c itself comes from a display table, otherwise we could
5726 end up in an infinite recursion. (An alternative could be to
5727 count the recursion depth of this function and signal an
5728 error when a certain maximum depth is reached.) Is it worth
5730 if (success_p
&& it
->dpvec
== NULL
)
5733 struct charset
*unibyte
= CHARSET_FROM_ID (charset_unibyte
);
5734 enum { char_is_other
= 0, char_is_nbsp
, char_is_soft_hyphen
}
5735 nbsp_or_shy
= char_is_other
;
5736 int c
= it
->c
; /* This is the character to display. */
5738 if (! it
->multibyte_p
&& ! ASCII_CHAR_P (c
))
5740 xassert (SINGLE_BYTE_CHAR_P (c
));
5741 if (unibyte_display_via_language_environment
)
5743 c
= DECODE_CHAR (unibyte
, c
);
5745 c
= BYTE8_TO_CHAR (it
->c
);
5748 c
= BYTE8_TO_CHAR (it
->c
);
5752 && (dv
= DISP_CHAR_VECTOR (it
->dp
, c
),
5755 struct Lisp_Vector
*v
= XVECTOR (dv
);
5757 /* Return the first character from the display table
5758 entry, if not empty. If empty, don't display the
5759 current character. */
5762 it
->dpvec_char_len
= it
->len
;
5763 it
->dpvec
= v
->contents
;
5764 it
->dpend
= v
->contents
+ v
->header
.size
;
5765 it
->current
.dpvec_index
= 0;
5766 it
->dpvec_face_id
= -1;
5767 it
->saved_face_id
= it
->face_id
;
5768 it
->method
= GET_FROM_DISPLAY_VECTOR
;
5773 set_iterator_to_next (it
, 0);
5778 if (! NILP (lookup_glyphless_char_display (c
, it
)))
5780 if (it
->what
== IT_GLYPHLESS
)
5782 /* Don't display this character. */
5783 set_iterator_to_next (it
, 0);
5787 if (! ASCII_CHAR_P (c
) && ! NILP (Vnobreak_char_display
))
5788 nbsp_or_shy
= (c
== 0xA0 ? char_is_nbsp
5789 : c
== 0xAD ? char_is_soft_hyphen
5792 /* Translate control characters into `\003' or `^C' form.
5793 Control characters coming from a display table entry are
5794 currently not translated because we use IT->dpvec to hold
5795 the translation. This could easily be changed but I
5796 don't believe that it is worth doing.
5798 NBSP and SOFT-HYPEN are property translated too.
5800 Non-printable characters and raw-byte characters are also
5801 translated to octal form. */
5802 if (((c
< ' ' || c
== 127) /* ASCII control chars */
5803 ? (it
->area
!= TEXT_AREA
5804 /* In mode line, treat \n, \t like other crl chars. */
5807 && (it
->glyph_row
->mode_line_p
|| it
->avoid_cursor_p
))
5808 || (c
!= '\n' && c
!= '\t'))
5811 || ! CHAR_PRINTABLE_P (c
))))
5813 /* C is a control character, NBSP, SOFT-HYPEN, raw-byte,
5814 or a non-printable character which must be displayed
5815 either as '\003' or as `^C' where the '\\' and '^'
5816 can be defined in the display table. Fill
5817 IT->ctl_chars with glyphs for what we have to
5818 display. Then, set IT->dpvec to these glyphs. */
5822 EMACS_INT lface_id
= 0;
5825 /* Handle control characters with ^. */
5827 if (ASCII_CHAR_P (c
) && it
->ctl_arrow_p
)
5831 g
= '^'; /* default glyph for Control */
5832 /* Set IT->ctl_chars[0] to the glyph for `^'. */
5834 && (gc
= DISP_CTRL_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
5835 && GLYPH_CODE_CHAR_VALID_P (gc
))
5837 g
= GLYPH_CODE_CHAR (gc
);
5838 lface_id
= GLYPH_CODE_FACE (gc
);
5842 face_id
= merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
);
5844 else if (it
->f
== last_escape_glyph_frame
5845 && it
->face_id
== last_escape_glyph_face_id
)
5847 face_id
= last_escape_glyph_merged_face_id
;
5851 /* Merge the escape-glyph face into the current face. */
5852 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
5854 last_escape_glyph_frame
= it
->f
;
5855 last_escape_glyph_face_id
= it
->face_id
;
5856 last_escape_glyph_merged_face_id
= face_id
;
5859 XSETINT (it
->ctl_chars
[0], g
);
5860 XSETINT (it
->ctl_chars
[1], c
^ 0100);
5862 goto display_control
;
5865 /* Handle non-break space in the mode where it only gets
5868 if (EQ (Vnobreak_char_display
, Qt
)
5869 && nbsp_or_shy
== char_is_nbsp
)
5871 /* Merge the no-break-space face into the current face. */
5872 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
5876 XSETINT (it
->ctl_chars
[0], ' ');
5878 goto display_control
;
5881 /* Handle sequences that start with the "escape glyph". */
5883 /* the default escape glyph is \. */
5884 escape_glyph
= '\\';
5887 && (gc
= DISP_ESCAPE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
5888 && GLYPH_CODE_CHAR_VALID_P (gc
))
5890 escape_glyph
= GLYPH_CODE_CHAR (gc
);
5891 lface_id
= GLYPH_CODE_FACE (gc
);
5895 /* The display table specified a face.
5896 Merge it into face_id and also into escape_glyph. */
5897 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
5900 else if (it
->f
== last_escape_glyph_frame
5901 && it
->face_id
== last_escape_glyph_face_id
)
5903 face_id
= last_escape_glyph_merged_face_id
;
5907 /* Merge the escape-glyph face into the current face. */
5908 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
5910 last_escape_glyph_frame
= it
->f
;
5911 last_escape_glyph_face_id
= it
->face_id
;
5912 last_escape_glyph_merged_face_id
= face_id
;
5915 /* Handle soft hyphens in the mode where they only get
5918 if (EQ (Vnobreak_char_display
, Qt
)
5919 && nbsp_or_shy
== char_is_soft_hyphen
)
5921 XSETINT (it
->ctl_chars
[0], '-');
5923 goto display_control
;
5926 /* Handle non-break space and soft hyphen
5927 with the escape glyph. */
5931 XSETINT (it
->ctl_chars
[0], escape_glyph
);
5932 c
= (nbsp_or_shy
== char_is_nbsp
? ' ' : '-');
5933 XSETINT (it
->ctl_chars
[1], c
);
5935 goto display_control
;
5942 if (CHAR_BYTE8_P (c
))
5943 /* Display \200 instead of \17777600. */
5944 c
= CHAR_TO_BYTE8 (c
);
5945 len
= sprintf (str
, "%03o", c
);
5947 XSETINT (it
->ctl_chars
[0], escape_glyph
);
5948 for (i
= 0; i
< len
; i
++)
5949 XSETINT (it
->ctl_chars
[i
+ 1], str
[i
]);
5954 /* Set up IT->dpvec and return first character from it. */
5955 it
->dpvec_char_len
= it
->len
;
5956 it
->dpvec
= it
->ctl_chars
;
5957 it
->dpend
= it
->dpvec
+ ctl_len
;
5958 it
->current
.dpvec_index
= 0;
5959 it
->dpvec_face_id
= face_id
;
5960 it
->saved_face_id
= it
->face_id
;
5961 it
->method
= GET_FROM_DISPLAY_VECTOR
;
5965 it
->char_to_display
= c
;
5969 it
->char_to_display
= it
->c
;
5973 /* Adjust face id for a multibyte character. There are no multibyte
5974 character in unibyte text. */
5975 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
5978 && FRAME_WINDOW_P (it
->f
))
5980 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
5982 if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
>= 0)
5984 /* Automatic composition with glyph-string. */
5985 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
5987 it
->face_id
= face_for_font (it
->f
, LGSTRING_FONT (gstring
), face
);
5991 EMACS_INT pos
= (it
->s
? -1
5992 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
5993 : IT_CHARPOS (*it
));
5996 if (it
->what
== IT_CHARACTER
)
5997 c
= it
->char_to_display
;
6000 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
6004 for (i
= 0; i
< cmp
->glyph_len
; i
++)
6005 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
6008 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, pos
, it
->string
);
6013 /* Is this character the last one of a run of characters with
6014 box? If yes, set IT->end_of_box_run_p to 1. */
6018 if (it
->method
== GET_FROM_STRING
&& it
->sp
)
6020 int face_id
= underlying_face_id (it
);
6021 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
6025 if (face
->box
== FACE_NO_BOX
)
6027 /* If the box comes from face properties in a
6028 display string, check faces in that string. */
6029 int string_face_id
= face_after_it_pos (it
);
6030 it
->end_of_box_run_p
6031 = (FACE_FROM_ID (it
->f
, string_face_id
)->box
6034 /* Otherwise, the box comes from the underlying face.
6035 If this is the last string character displayed, check
6036 the next buffer location. */
6037 else if ((IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
) - 1)
6038 && (it
->current
.overlay_string_index
6039 == it
->n_overlay_strings
- 1))
6043 struct text_pos pos
= it
->current
.pos
;
6044 INC_TEXT_POS (pos
, it
->multibyte_p
);
6046 next_face_id
= face_at_buffer_position
6047 (it
->w
, CHARPOS (pos
), it
->region_beg_charpos
,
6048 it
->region_end_charpos
, &ignore
,
6049 (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
), 0,
6051 it
->end_of_box_run_p
6052 = (FACE_FROM_ID (it
->f
, next_face_id
)->box
6059 int face_id
= face_after_it_pos (it
);
6060 it
->end_of_box_run_p
6061 = (face_id
!= it
->face_id
6062 && FACE_FROM_ID (it
->f
, face_id
)->box
== FACE_NO_BOX
);
6066 /* Value is 0 if end of buffer or string reached. */
6071 /* Move IT to the next display element.
6073 RESEAT_P non-zero means if called on a newline in buffer text,
6074 skip to the next visible line start.
6076 Functions get_next_display_element and set_iterator_to_next are
6077 separate because I find this arrangement easier to handle than a
6078 get_next_display_element function that also increments IT's
6079 position. The way it is we can first look at an iterator's current
6080 display element, decide whether it fits on a line, and if it does,
6081 increment the iterator position. The other way around we probably
6082 would either need a flag indicating whether the iterator has to be
6083 incremented the next time, or we would have to implement a
6084 decrement position function which would not be easy to write. */
6087 set_iterator_to_next (struct it
*it
, int reseat_p
)
6089 /* Reset flags indicating start and end of a sequence of characters
6090 with box. Reset them at the start of this function because
6091 moving the iterator to a new position might set them. */
6092 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
6096 case GET_FROM_BUFFER
:
6097 /* The current display element of IT is a character from
6098 current_buffer. Advance in the buffer, and maybe skip over
6099 invisible lines that are so because of selective display. */
6100 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
6101 reseat_at_next_visible_line_start (it
, 0);
6102 else if (it
->cmp_it
.id
>= 0)
6104 /* We are currently getting glyphs from a composition. */
6109 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6110 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6111 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6113 it
->cmp_it
.from
= it
->cmp_it
.to
;
6118 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6120 it
->end_charpos
, Qnil
);
6123 else if (! it
->cmp_it
.reversed_p
)
6125 /* Composition created while scanning forward. */
6126 /* Update IT's char/byte positions to point to the first
6127 character of the next grapheme cluster, or to the
6128 character visually after the current composition. */
6129 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6130 bidi_move_to_visually_next (&it
->bidi_it
);
6131 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6132 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6134 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6136 /* Proceed to the next grapheme cluster. */
6137 it
->cmp_it
.from
= it
->cmp_it
.to
;
6141 /* No more grapheme clusters in this composition.
6142 Find the next stop position. */
6143 EMACS_INT stop
= it
->end_charpos
;
6144 if (it
->bidi_it
.scan_dir
< 0)
6145 /* Now we are scanning backward and don't know
6148 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6149 IT_BYTEPOS (*it
), stop
, Qnil
);
6154 /* Composition created while scanning backward. */
6155 /* Update IT's char/byte positions to point to the last
6156 character of the previous grapheme cluster, or the
6157 character visually after the current composition. */
6158 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6159 bidi_move_to_visually_next (&it
->bidi_it
);
6160 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6161 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6162 if (it
->cmp_it
.from
> 0)
6164 /* Proceed to the previous grapheme cluster. */
6165 it
->cmp_it
.to
= it
->cmp_it
.from
;
6169 /* No more grapheme clusters in this composition.
6170 Find the next stop position. */
6171 EMACS_INT stop
= it
->end_charpos
;
6172 if (it
->bidi_it
.scan_dir
< 0)
6173 /* Now we are scanning backward and don't know
6176 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6177 IT_BYTEPOS (*it
), stop
, Qnil
);
6183 xassert (it
->len
!= 0);
6187 IT_BYTEPOS (*it
) += it
->len
;
6188 IT_CHARPOS (*it
) += 1;
6192 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
6193 /* If this is a new paragraph, determine its base
6194 direction (a.k.a. its base embedding level). */
6195 if (it
->bidi_it
.new_paragraph
)
6196 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
6197 bidi_move_to_visually_next (&it
->bidi_it
);
6198 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6199 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6200 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
6202 /* As the scan direction was changed, we must
6203 re-compute the stop position for composition. */
6204 EMACS_INT stop
= it
->end_charpos
;
6205 if (it
->bidi_it
.scan_dir
< 0)
6207 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6208 IT_BYTEPOS (*it
), stop
, Qnil
);
6211 xassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
6215 case GET_FROM_C_STRING
:
6216 /* Current display element of IT is from a C string. */
6217 IT_BYTEPOS (*it
) += it
->len
;
6218 IT_CHARPOS (*it
) += 1;
6221 case GET_FROM_DISPLAY_VECTOR
:
6222 /* Current display element of IT is from a display table entry.
6223 Advance in the display table definition. Reset it to null if
6224 end reached, and continue with characters from buffers/
6226 ++it
->current
.dpvec_index
;
6228 /* Restore face of the iterator to what they were before the
6229 display vector entry (these entries may contain faces). */
6230 it
->face_id
= it
->saved_face_id
;
6232 if (it
->dpvec
+ it
->current
.dpvec_index
== it
->dpend
)
6234 int recheck_faces
= it
->ellipsis_p
;
6237 it
->method
= GET_FROM_C_STRING
;
6238 else if (STRINGP (it
->string
))
6239 it
->method
= GET_FROM_STRING
;
6242 it
->method
= GET_FROM_BUFFER
;
6243 it
->object
= it
->w
->buffer
;
6247 it
->current
.dpvec_index
= -1;
6249 /* Skip over characters which were displayed via IT->dpvec. */
6250 if (it
->dpvec_char_len
< 0)
6251 reseat_at_next_visible_line_start (it
, 1);
6252 else if (it
->dpvec_char_len
> 0)
6254 if (it
->method
== GET_FROM_STRING
6255 && it
->n_overlay_strings
> 0)
6256 it
->ignore_overlay_strings_at_pos_p
= 1;
6257 it
->len
= it
->dpvec_char_len
;
6258 set_iterator_to_next (it
, reseat_p
);
6261 /* Maybe recheck faces after display vector */
6263 it
->stop_charpos
= IT_CHARPOS (*it
);
6267 case GET_FROM_STRING
:
6268 /* Current display element is a character from a Lisp string. */
6269 xassert (it
->s
== NULL
&& STRINGP (it
->string
));
6270 if (it
->cmp_it
.id
>= 0)
6272 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6273 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6274 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6275 it
->cmp_it
.from
= it
->cmp_it
.to
;
6279 composition_compute_stop_pos (&it
->cmp_it
,
6280 IT_STRING_CHARPOS (*it
),
6281 IT_STRING_BYTEPOS (*it
),
6282 it
->end_charpos
, it
->string
);
6287 IT_STRING_BYTEPOS (*it
) += it
->len
;
6288 IT_STRING_CHARPOS (*it
) += 1;
6291 consider_string_end
:
6293 if (it
->current
.overlay_string_index
>= 0)
6295 /* IT->string is an overlay string. Advance to the
6296 next, if there is one. */
6297 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
6300 next_overlay_string (it
);
6302 setup_for_ellipsis (it
, 0);
6307 /* IT->string is not an overlay string. If we reached
6308 its end, and there is something on IT->stack, proceed
6309 with what is on the stack. This can be either another
6310 string, this time an overlay string, or a buffer. */
6311 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
6315 if (it
->method
== GET_FROM_STRING
)
6316 goto consider_string_end
;
6321 case GET_FROM_IMAGE
:
6322 case GET_FROM_STRETCH
:
6323 /* The position etc with which we have to proceed are on
6324 the stack. The position may be at the end of a string,
6325 if the `display' property takes up the whole string. */
6326 xassert (it
->sp
> 0);
6328 if (it
->method
== GET_FROM_STRING
)
6329 goto consider_string_end
;
6333 /* There are no other methods defined, so this should be a bug. */
6337 xassert (it
->method
!= GET_FROM_STRING
6338 || (STRINGP (it
->string
)
6339 && IT_STRING_CHARPOS (*it
) >= 0));
6342 /* Load IT's display element fields with information about the next
6343 display element which comes from a display table entry or from the
6344 result of translating a control character to one of the forms `^C'
6347 IT->dpvec holds the glyphs to return as characters.
6348 IT->saved_face_id holds the face id before the display vector--it
6349 is restored into IT->face_id in set_iterator_to_next. */
6352 next_element_from_display_vector (struct it
*it
)
6357 xassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
6359 it
->face_id
= it
->saved_face_id
;
6361 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
6362 That seemed totally bogus - so I changed it... */
6363 gc
= it
->dpvec
[it
->current
.dpvec_index
];
6365 if (GLYPH_CODE_P (gc
) && GLYPH_CODE_CHAR_VALID_P (gc
))
6367 it
->c
= GLYPH_CODE_CHAR (gc
);
6368 it
->len
= CHAR_BYTES (it
->c
);
6370 /* The entry may contain a face id to use. Such a face id is
6371 the id of a Lisp face, not a realized face. A face id of
6372 zero means no face is specified. */
6373 if (it
->dpvec_face_id
>= 0)
6374 it
->face_id
= it
->dpvec_face_id
;
6377 EMACS_INT lface_id
= GLYPH_CODE_FACE (gc
);
6379 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6384 /* Display table entry is invalid. Return a space. */
6385 it
->c
= ' ', it
->len
= 1;
6387 /* Don't change position and object of the iterator here. They are
6388 still the values of the character that had this display table
6389 entry or was translated, and that's what we want. */
6390 it
->what
= IT_CHARACTER
;
6395 /* Load IT with the next display element from Lisp string IT->string.
6396 IT->current.string_pos is the current position within the string.
6397 If IT->current.overlay_string_index >= 0, the Lisp string is an
6401 next_element_from_string (struct it
*it
)
6403 struct text_pos position
;
6405 xassert (STRINGP (it
->string
));
6406 xassert (IT_STRING_CHARPOS (*it
) >= 0);
6407 position
= it
->current
.string_pos
;
6409 /* Time to check for invisible text? */
6410 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
6411 && IT_STRING_CHARPOS (*it
) == it
->stop_charpos
)
6415 /* Since a handler may have changed IT->method, we must
6417 return GET_NEXT_DISPLAY_ELEMENT (it
);
6420 if (it
->current
.overlay_string_index
>= 0)
6422 /* Get the next character from an overlay string. In overlay
6423 strings, There is no field width or padding with spaces to
6425 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
6430 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
6431 IT_STRING_BYTEPOS (*it
), SCHARS (it
->string
))
6432 && next_element_from_composition (it
))
6436 else if (STRING_MULTIBYTE (it
->string
))
6438 const unsigned char *s
= (SDATA (it
->string
)
6439 + IT_STRING_BYTEPOS (*it
));
6440 it
->c
= string_char_and_length (s
, &it
->len
);
6444 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
6450 /* Get the next character from a Lisp string that is not an
6451 overlay string. Such strings come from the mode line, for
6452 example. We may have to pad with spaces, or truncate the
6453 string. See also next_element_from_c_string. */
6454 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
6459 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
6461 /* Pad with spaces. */
6462 it
->c
= ' ', it
->len
= 1;
6463 CHARPOS (position
) = BYTEPOS (position
) = -1;
6465 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
6466 IT_STRING_BYTEPOS (*it
), it
->string_nchars
)
6467 && next_element_from_composition (it
))
6471 else if (STRING_MULTIBYTE (it
->string
))
6473 const unsigned char *s
= (SDATA (it
->string
)
6474 + IT_STRING_BYTEPOS (*it
));
6475 it
->c
= string_char_and_length (s
, &it
->len
);
6479 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
6484 /* Record what we have and where it came from. */
6485 it
->what
= IT_CHARACTER
;
6486 it
->object
= it
->string
;
6487 it
->position
= position
;
6492 /* Load IT with next display element from C string IT->s.
6493 IT->string_nchars is the maximum number of characters to return
6494 from the string. IT->end_charpos may be greater than
6495 IT->string_nchars when this function is called, in which case we
6496 may have to return padding spaces. Value is zero if end of string
6497 reached, including padding spaces. */
6500 next_element_from_c_string (struct it
*it
)
6505 it
->what
= IT_CHARACTER
;
6506 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
6509 /* IT's position can be greater IT->string_nchars in case a field
6510 width or precision has been specified when the iterator was
6512 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
6514 /* End of the game. */
6518 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
6520 /* Pad with spaces. */
6521 it
->c
= ' ', it
->len
= 1;
6522 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
6524 else if (it
->multibyte_p
)
6525 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
), &it
->len
);
6527 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
6533 /* Set up IT to return characters from an ellipsis, if appropriate.
6534 The definition of the ellipsis glyphs may come from a display table
6535 entry. This function fills IT with the first glyph from the
6536 ellipsis if an ellipsis is to be displayed. */
6539 next_element_from_ellipsis (struct it
*it
)
6541 if (it
->selective_display_ellipsis_p
)
6542 setup_for_ellipsis (it
, it
->len
);
6545 /* The face at the current position may be different from the
6546 face we find after the invisible text. Remember what it
6547 was in IT->saved_face_id, and signal that it's there by
6548 setting face_before_selective_p. */
6549 it
->saved_face_id
= it
->face_id
;
6550 it
->method
= GET_FROM_BUFFER
;
6551 it
->object
= it
->w
->buffer
;
6552 reseat_at_next_visible_line_start (it
, 1);
6553 it
->face_before_selective_p
= 1;
6556 return GET_NEXT_DISPLAY_ELEMENT (it
);
6560 /* Deliver an image display element. The iterator IT is already
6561 filled with image information (done in handle_display_prop). Value
6566 next_element_from_image (struct it
*it
)
6568 it
->what
= IT_IMAGE
;
6569 it
->ignore_overlay_strings_at_pos_p
= 0;
6574 /* Fill iterator IT with next display element from a stretch glyph
6575 property. IT->object is the value of the text property. Value is
6579 next_element_from_stretch (struct it
*it
)
6581 it
->what
= IT_STRETCH
;
6585 /* Scan forward from CHARPOS in the current buffer, until we find a
6586 stop position > current IT's position. Then handle the stop
6587 position before that. This is called when we bump into a stop
6588 position while reordering bidirectional text. CHARPOS should be
6589 the last previously processed stop_pos (or BEGV, if none were
6590 processed yet) whose position is less that IT's current
6594 handle_stop_backwards (struct it
*it
, EMACS_INT charpos
)
6596 EMACS_INT where_we_are
= IT_CHARPOS (*it
);
6597 struct display_pos save_current
= it
->current
;
6598 struct text_pos save_position
= it
->position
;
6599 struct text_pos pos1
;
6600 EMACS_INT next_stop
;
6602 /* Scan in strict logical order. */
6606 it
->prev_stop
= charpos
;
6607 SET_TEXT_POS (pos1
, charpos
, CHAR_TO_BYTE (charpos
));
6608 reseat_1 (it
, pos1
, 0);
6609 compute_stop_pos (it
);
6610 /* We must advance forward, right? */
6611 if (it
->stop_charpos
<= it
->prev_stop
)
6613 charpos
= it
->stop_charpos
;
6615 while (charpos
<= where_we_are
);
6617 next_stop
= it
->stop_charpos
;
6618 it
->stop_charpos
= it
->prev_stop
;
6620 it
->current
= save_current
;
6621 it
->position
= save_position
;
6623 it
->stop_charpos
= next_stop
;
6626 /* Load IT with the next display element from current_buffer. Value
6627 is zero if end of buffer reached. IT->stop_charpos is the next
6628 position at which to stop and check for text properties or buffer
6632 next_element_from_buffer (struct it
*it
)
6636 xassert (IT_CHARPOS (*it
) >= BEGV
);
6638 /* With bidi reordering, the character to display might not be the
6639 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
6640 we were reseat()ed to a new buffer position, which is potentially
6641 a different paragraph. */
6642 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
6644 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
6645 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
6646 if (it
->bidi_it
.bytepos
== ZV_BYTE
)
6648 /* Nothing to do, but reset the FIRST_ELT flag, like
6649 bidi_paragraph_init does, because we are not going to
6651 it
->bidi_it
.first_elt
= 0;
6653 else if (it
->bidi_it
.bytepos
== BEGV_BYTE
6654 /* FIXME: Should support all Unicode line separators. */
6655 || FETCH_CHAR (it
->bidi_it
.bytepos
- 1) == '\n'
6656 || FETCH_CHAR (it
->bidi_it
.bytepos
) == '\n')
6658 /* If we are at the beginning of a line, we can produce the
6659 next element right away. */
6660 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
6661 bidi_move_to_visually_next (&it
->bidi_it
);
6665 EMACS_INT orig_bytepos
= IT_BYTEPOS (*it
);
6667 /* We need to prime the bidi iterator starting at the line's
6668 beginning, before we will be able to produce the next
6670 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
), -1);
6671 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
6672 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
6673 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
6674 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
6677 /* Now return to buffer position where we were asked to
6678 get the next display element, and produce that. */
6679 bidi_move_to_visually_next (&it
->bidi_it
);
6681 while (it
->bidi_it
.bytepos
!= orig_bytepos
6682 && it
->bidi_it
.bytepos
< ZV_BYTE
);
6685 it
->bidi_it
.first_elt
= 0; /* paranoia: bidi.c does this */
6686 /* Adjust IT's position information to where we ended up. */
6687 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6688 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6689 SET_TEXT_POS (it
->position
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
6691 EMACS_INT stop
= it
->end_charpos
;
6692 if (it
->bidi_it
.scan_dir
< 0)
6694 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6695 IT_BYTEPOS (*it
), stop
, Qnil
);
6699 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
6701 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
6703 int overlay_strings_follow_p
;
6705 /* End of the game, except when overlay strings follow that
6706 haven't been returned yet. */
6707 if (it
->overlay_strings_at_end_processed_p
)
6708 overlay_strings_follow_p
= 0;
6711 it
->overlay_strings_at_end_processed_p
= 1;
6712 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
6715 if (overlay_strings_follow_p
)
6716 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
6720 it
->position
= it
->current
.pos
;
6724 else if (!(!it
->bidi_p
6725 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
6726 || IT_CHARPOS (*it
) == it
->stop_charpos
))
6728 /* With bidi non-linear iteration, we could find ourselves
6729 far beyond the last computed stop_charpos, with several
6730 other stop positions in between that we missed. Scan
6731 them all now, in buffer's logical order, until we find
6732 and handle the last stop_charpos that precedes our
6733 current position. */
6734 handle_stop_backwards (it
, it
->stop_charpos
);
6735 return GET_NEXT_DISPLAY_ELEMENT (it
);
6741 /* Take note of the stop position we just moved across,
6742 for when we will move back across it. */
6743 it
->prev_stop
= it
->stop_charpos
;
6744 /* If we are at base paragraph embedding level, take
6745 note of the last stop position seen at this
6747 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
6748 it
->base_level_stop
= it
->stop_charpos
;
6751 return GET_NEXT_DISPLAY_ELEMENT (it
);
6755 /* We can sometimes back up for reasons that have nothing
6756 to do with bidi reordering. E.g., compositions. The
6757 code below is only needed when we are above the base
6758 embedding level, so test for that explicitly. */
6759 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
)
6760 && IT_CHARPOS (*it
) < it
->prev_stop
)
6762 if (it
->base_level_stop
<= 0)
6763 it
->base_level_stop
= BEGV
;
6764 if (IT_CHARPOS (*it
) < it
->base_level_stop
)
6766 handle_stop_backwards (it
, it
->base_level_stop
);
6767 return GET_NEXT_DISPLAY_ELEMENT (it
);
6771 /* No face changes, overlays etc. in sight, so just return a
6772 character from current_buffer. */
6776 /* Maybe run the redisplay end trigger hook. Performance note:
6777 This doesn't seem to cost measurable time. */
6778 if (it
->redisplay_end_trigger_charpos
6780 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
6781 run_redisplay_end_trigger_hook (it
);
6783 stop
= it
->bidi_it
.scan_dir
< 0 ? -1 : it
->end_charpos
;
6784 if (CHAR_COMPOSED_P (it
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
6786 && next_element_from_composition (it
))
6791 /* Get the next character, maybe multibyte. */
6792 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
6793 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
6794 it
->c
= STRING_CHAR_AND_LENGTH (p
, it
->len
);
6796 it
->c
= *p
, it
->len
= 1;
6798 /* Record what we have and where it came from. */
6799 it
->what
= IT_CHARACTER
;
6800 it
->object
= it
->w
->buffer
;
6801 it
->position
= it
->current
.pos
;
6803 /* Normally we return the character found above, except when we
6804 really want to return an ellipsis for selective display. */
6809 /* A value of selective > 0 means hide lines indented more
6810 than that number of columns. */
6811 if (it
->selective
> 0
6812 && IT_CHARPOS (*it
) + 1 < ZV
6813 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
6814 IT_BYTEPOS (*it
) + 1,
6815 (double) it
->selective
)) /* iftc */
6817 success_p
= next_element_from_ellipsis (it
);
6818 it
->dpvec_char_len
= -1;
6821 else if (it
->c
== '\r' && it
->selective
== -1)
6823 /* A value of selective == -1 means that everything from the
6824 CR to the end of the line is invisible, with maybe an
6825 ellipsis displayed for it. */
6826 success_p
= next_element_from_ellipsis (it
);
6827 it
->dpvec_char_len
= -1;
6832 /* Value is zero if end of buffer reached. */
6833 xassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
6838 /* Run the redisplay end trigger hook for IT. */
6841 run_redisplay_end_trigger_hook (struct it
*it
)
6843 Lisp_Object args
[3];
6845 /* IT->glyph_row should be non-null, i.e. we should be actually
6846 displaying something, or otherwise we should not run the hook. */
6847 xassert (it
->glyph_row
);
6849 /* Set up hook arguments. */
6850 args
[0] = Qredisplay_end_trigger_functions
;
6851 args
[1] = it
->window
;
6852 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
6853 it
->redisplay_end_trigger_charpos
= 0;
6855 /* Since we are *trying* to run these functions, don't try to run
6856 them again, even if they get an error. */
6857 it
->w
->redisplay_end_trigger
= Qnil
;
6858 Frun_hook_with_args (3, args
);
6860 /* Notice if it changed the face of the character we are on. */
6861 handle_face_prop (it
);
6865 /* Deliver a composition display element. Unlike the other
6866 next_element_from_XXX, this function is not registered in the array
6867 get_next_element[]. It is called from next_element_from_buffer and
6868 next_element_from_string when necessary. */
6871 next_element_from_composition (struct it
*it
)
6873 it
->what
= IT_COMPOSITION
;
6874 it
->len
= it
->cmp_it
.nbytes
;
6875 if (STRINGP (it
->string
))
6879 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6880 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6883 it
->position
= it
->current
.string_pos
;
6884 it
->object
= it
->string
;
6885 it
->c
= composition_update_it (&it
->cmp_it
, IT_STRING_CHARPOS (*it
),
6886 IT_STRING_BYTEPOS (*it
), it
->string
);
6892 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6893 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6896 if (it
->bidi_it
.new_paragraph
)
6897 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
6898 /* Resync the bidi iterator with IT's new position.
6899 FIXME: this doesn't support bidirectional text. */
6900 while (it
->bidi_it
.charpos
< IT_CHARPOS (*it
))
6901 bidi_move_to_visually_next (&it
->bidi_it
);
6905 it
->position
= it
->current
.pos
;
6906 it
->object
= it
->w
->buffer
;
6907 it
->c
= composition_update_it (&it
->cmp_it
, IT_CHARPOS (*it
),
6908 IT_BYTEPOS (*it
), Qnil
);
6915 /***********************************************************************
6916 Moving an iterator without producing glyphs
6917 ***********************************************************************/
6919 /* Check if iterator is at a position corresponding to a valid buffer
6920 position after some move_it_ call. */
6922 #define IT_POS_VALID_AFTER_MOVE_P(it) \
6923 ((it)->method == GET_FROM_STRING \
6924 ? IT_STRING_CHARPOS (*it) == 0 \
6928 /* Move iterator IT to a specified buffer or X position within one
6929 line on the display without producing glyphs.
6931 OP should be a bit mask including some or all of these bits:
6932 MOVE_TO_X: Stop upon reaching x-position TO_X.
6933 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
6934 Regardless of OP's value, stop upon reaching the end of the display line.
6936 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
6937 This means, in particular, that TO_X includes window's horizontal
6940 The return value has several possible values that
6941 say what condition caused the scan to stop:
6943 MOVE_POS_MATCH_OR_ZV
6944 - when TO_POS or ZV was reached.
6947 -when TO_X was reached before TO_POS or ZV were reached.
6950 - when we reached the end of the display area and the line must
6954 - when we reached the end of the display area and the line is
6958 - when we stopped at a line end, i.e. a newline or a CR and selective
6961 static enum move_it_result
6962 move_it_in_display_line_to (struct it
*it
,
6963 EMACS_INT to_charpos
, int to_x
,
6964 enum move_operation_enum op
)
6966 enum move_it_result result
= MOVE_UNDEFINED
;
6967 struct glyph_row
*saved_glyph_row
;
6968 struct it wrap_it
, atpos_it
, atx_it
;
6970 enum it_method prev_method
= it
->method
;
6971 EMACS_INT prev_pos
= IT_CHARPOS (*it
);
6973 /* Don't produce glyphs in produce_glyphs. */
6974 saved_glyph_row
= it
->glyph_row
;
6975 it
->glyph_row
= NULL
;
6977 /* Use wrap_it to save a copy of IT wherever a word wrap could
6978 occur. Use atpos_it to save a copy of IT at the desired buffer
6979 position, if found, so that we can scan ahead and check if the
6980 word later overshoots the window edge. Use atx_it similarly, for
6986 #define BUFFER_POS_REACHED_P() \
6987 ((op & MOVE_TO_POS) != 0 \
6988 && BUFFERP (it->object) \
6989 && (IT_CHARPOS (*it) == to_charpos \
6990 || (!it->bidi_p && IT_CHARPOS (*it) > to_charpos)) \
6991 && (it->method == GET_FROM_BUFFER \
6992 || (it->method == GET_FROM_DISPLAY_VECTOR \
6993 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
6995 /* If there's a line-/wrap-prefix, handle it. */
6996 if (it
->hpos
== 0 && it
->method
== GET_FROM_BUFFER
6997 && it
->current_y
< it
->last_visible_y
)
6998 handle_line_prefix (it
);
7000 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7001 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7005 int x
, i
, ascent
= 0, descent
= 0;
7007 /* Utility macro to reset an iterator with x, ascent, and descent. */
7008 #define IT_RESET_X_ASCENT_DESCENT(IT) \
7009 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
7010 (IT)->max_descent = descent)
7012 /* Stop if we move beyond TO_CHARPOS (after an image or stretch
7014 if ((op
& MOVE_TO_POS
) != 0
7015 && BUFFERP (it
->object
)
7016 && it
->method
== GET_FROM_BUFFER
7017 && ((!it
->bidi_p
&& IT_CHARPOS (*it
) > to_charpos
)
7019 && (prev_method
== GET_FROM_IMAGE
7020 || prev_method
== GET_FROM_STRETCH
)
7021 /* Passed TO_CHARPOS from left to right. */
7022 && ((prev_pos
< to_charpos
7023 && IT_CHARPOS (*it
) > to_charpos
)
7024 /* Passed TO_CHARPOS from right to left. */
7025 || (prev_pos
> to_charpos
7026 && IT_CHARPOS (*it
) < to_charpos
)))))
7028 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7030 result
= MOVE_POS_MATCH_OR_ZV
;
7033 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
7034 /* If wrap_it is valid, the current position might be in a
7035 word that is wrapped. So, save the iterator in
7036 atpos_it and continue to see if wrapping happens. */
7040 prev_method
= it
->method
;
7041 if (it
->method
== GET_FROM_BUFFER
)
7042 prev_pos
= IT_CHARPOS (*it
);
7043 /* Stop when ZV reached.
7044 We used to stop here when TO_CHARPOS reached as well, but that is
7045 too soon if this glyph does not fit on this line. So we handle it
7046 explicitly below. */
7047 if (!get_next_display_element (it
))
7049 result
= MOVE_POS_MATCH_OR_ZV
;
7053 if (it
->line_wrap
== TRUNCATE
)
7055 if (BUFFER_POS_REACHED_P ())
7057 result
= MOVE_POS_MATCH_OR_ZV
;
7063 if (it
->line_wrap
== WORD_WRAP
)
7065 if (IT_DISPLAYING_WHITESPACE (it
))
7069 /* We have reached a glyph that follows one or more
7070 whitespace characters. If the position is
7071 already found, we are done. */
7072 if (atpos_it
.sp
>= 0)
7075 result
= MOVE_POS_MATCH_OR_ZV
;
7081 result
= MOVE_X_REACHED
;
7084 /* Otherwise, we can wrap here. */
7091 /* Remember the line height for the current line, in case
7092 the next element doesn't fit on the line. */
7093 ascent
= it
->max_ascent
;
7094 descent
= it
->max_descent
;
7096 /* The call to produce_glyphs will get the metrics of the
7097 display element IT is loaded with. Record the x-position
7098 before this display element, in case it doesn't fit on the
7102 PRODUCE_GLYPHS (it
);
7104 if (it
->area
!= TEXT_AREA
)
7106 set_iterator_to_next (it
, 1);
7107 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7108 SET_TEXT_POS (this_line_min_pos
,
7109 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7113 /* The number of glyphs we get back in IT->nglyphs will normally
7114 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
7115 character on a terminal frame, or (iii) a line end. For the
7116 second case, IT->nglyphs - 1 padding glyphs will be present.
7117 (On X frames, there is only one glyph produced for a
7118 composite character.)
7120 The behavior implemented below means, for continuation lines,
7121 that as many spaces of a TAB as fit on the current line are
7122 displayed there. For terminal frames, as many glyphs of a
7123 multi-glyph character are displayed in the current line, too.
7124 This is what the old redisplay code did, and we keep it that
7125 way. Under X, the whole shape of a complex character must
7126 fit on the line or it will be completely displayed in the
7129 Note that both for tabs and padding glyphs, all glyphs have
7133 /* More than one glyph or glyph doesn't fit on line. All
7134 glyphs have the same width. */
7135 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
7137 int x_before_this_char
= x
;
7138 int hpos_before_this_char
= it
->hpos
;
7140 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
7142 new_x
= x
+ single_glyph_width
;
7144 /* We want to leave anything reaching TO_X to the caller. */
7145 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
7147 if (BUFFER_POS_REACHED_P ())
7149 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7150 goto buffer_pos_reached
;
7151 if (atpos_it
.sp
< 0)
7154 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
7159 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7162 result
= MOVE_X_REACHED
;
7168 IT_RESET_X_ASCENT_DESCENT (&atx_it
);
7173 if (/* Lines are continued. */
7174 it
->line_wrap
!= TRUNCATE
7175 && (/* And glyph doesn't fit on the line. */
7176 new_x
> it
->last_visible_x
7177 /* Or it fits exactly and we're on a window
7179 || (new_x
== it
->last_visible_x
7180 && FRAME_WINDOW_P (it
->f
))))
7182 if (/* IT->hpos == 0 means the very first glyph
7183 doesn't fit on the line, e.g. a wide image. */
7185 || (new_x
== it
->last_visible_x
7186 && FRAME_WINDOW_P (it
->f
)))
7189 it
->current_x
= new_x
;
7191 /* The character's last glyph just barely fits
7193 if (i
== it
->nglyphs
- 1)
7195 /* If this is the destination position,
7196 return a position *before* it in this row,
7197 now that we know it fits in this row. */
7198 if (BUFFER_POS_REACHED_P ())
7200 if (it
->line_wrap
!= WORD_WRAP
7203 it
->hpos
= hpos_before_this_char
;
7204 it
->current_x
= x_before_this_char
;
7205 result
= MOVE_POS_MATCH_OR_ZV
;
7208 if (it
->line_wrap
== WORD_WRAP
7212 atpos_it
.current_x
= x_before_this_char
;
7213 atpos_it
.hpos
= hpos_before_this_char
;
7217 set_iterator_to_next (it
, 1);
7218 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7219 SET_TEXT_POS (this_line_min_pos
,
7220 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7221 /* On graphical terminals, newlines may
7222 "overflow" into the fringe if
7223 overflow-newline-into-fringe is non-nil.
7224 On text-only terminals, newlines may
7225 overflow into the last glyph on the
7227 if (!FRAME_WINDOW_P (it
->f
)
7228 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
7230 if (!get_next_display_element (it
))
7232 result
= MOVE_POS_MATCH_OR_ZV
;
7235 if (BUFFER_POS_REACHED_P ())
7237 if (ITERATOR_AT_END_OF_LINE_P (it
))
7238 result
= MOVE_POS_MATCH_OR_ZV
;
7240 result
= MOVE_LINE_CONTINUED
;
7243 if (ITERATOR_AT_END_OF_LINE_P (it
))
7245 result
= MOVE_NEWLINE_OR_CR
;
7252 IT_RESET_X_ASCENT_DESCENT (it
);
7254 if (wrap_it
.sp
>= 0)
7261 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
7263 result
= MOVE_LINE_CONTINUED
;
7267 if (BUFFER_POS_REACHED_P ())
7269 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7270 goto buffer_pos_reached
;
7271 if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
7274 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
7278 if (new_x
> it
->first_visible_x
)
7280 /* Glyph is visible. Increment number of glyphs that
7281 would be displayed. */
7286 if (result
!= MOVE_UNDEFINED
)
7289 else if (BUFFER_POS_REACHED_P ())
7292 IT_RESET_X_ASCENT_DESCENT (it
);
7293 result
= MOVE_POS_MATCH_OR_ZV
;
7296 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
7298 /* Stop when TO_X specified and reached. This check is
7299 necessary here because of lines consisting of a line end,
7300 only. The line end will not produce any glyphs and we
7301 would never get MOVE_X_REACHED. */
7302 xassert (it
->nglyphs
== 0);
7303 result
= MOVE_X_REACHED
;
7307 /* Is this a line end? If yes, we're done. */
7308 if (ITERATOR_AT_END_OF_LINE_P (it
))
7310 result
= MOVE_NEWLINE_OR_CR
;
7314 if (it
->method
== GET_FROM_BUFFER
)
7315 prev_pos
= IT_CHARPOS (*it
);
7316 /* The current display element has been consumed. Advance
7318 set_iterator_to_next (it
, 1);
7319 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7320 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7322 /* Stop if lines are truncated and IT's current x-position is
7323 past the right edge of the window now. */
7324 if (it
->line_wrap
== TRUNCATE
7325 && it
->current_x
>= it
->last_visible_x
)
7327 if (!FRAME_WINDOW_P (it
->f
)
7328 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
7330 if (!get_next_display_element (it
)
7331 || BUFFER_POS_REACHED_P ())
7333 result
= MOVE_POS_MATCH_OR_ZV
;
7336 if (ITERATOR_AT_END_OF_LINE_P (it
))
7338 result
= MOVE_NEWLINE_OR_CR
;
7342 result
= MOVE_LINE_TRUNCATED
;
7345 #undef IT_RESET_X_ASCENT_DESCENT
7348 #undef BUFFER_POS_REACHED_P
7350 /* If we scanned beyond to_pos and didn't find a point to wrap at,
7351 restore the saved iterator. */
7352 if (atpos_it
.sp
>= 0)
7354 else if (atx_it
.sp
>= 0)
7359 /* Restore the iterator settings altered at the beginning of this
7361 it
->glyph_row
= saved_glyph_row
;
7365 /* For external use. */
7367 move_it_in_display_line (struct it
*it
,
7368 EMACS_INT to_charpos
, int to_x
,
7369 enum move_operation_enum op
)
7371 if (it
->line_wrap
== WORD_WRAP
7372 && (op
& MOVE_TO_X
))
7374 struct it save_it
= *it
;
7375 int skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
7376 /* When word-wrap is on, TO_X may lie past the end
7377 of a wrapped line. Then it->current is the
7378 character on the next line, so backtrack to the
7379 space before the wrap point. */
7380 if (skip
== MOVE_LINE_CONTINUED
)
7382 int prev_x
= max (it
->current_x
- 1, 0);
7384 move_it_in_display_line_to
7385 (it
, -1, prev_x
, MOVE_TO_X
);
7389 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
7393 /* Move IT forward until it satisfies one or more of the criteria in
7394 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
7396 OP is a bit-mask that specifies where to stop, and in particular,
7397 which of those four position arguments makes a difference. See the
7398 description of enum move_operation_enum.
7400 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
7401 screen line, this function will set IT to the next position >
7405 move_it_to (struct it
*it
, EMACS_INT to_charpos
, int to_x
, int to_y
, int to_vpos
, int op
)
7407 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
7408 int line_height
, line_start_x
= 0, reached
= 0;
7412 if (op
& MOVE_TO_VPOS
)
7414 /* If no TO_CHARPOS and no TO_X specified, stop at the
7415 start of the line TO_VPOS. */
7416 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
7418 if (it
->vpos
== to_vpos
)
7424 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
7428 /* TO_VPOS >= 0 means stop at TO_X in the line at
7429 TO_VPOS, or at TO_POS, whichever comes first. */
7430 if (it
->vpos
== to_vpos
)
7436 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
7438 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
7443 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
7445 /* We have reached TO_X but not in the line we want. */
7446 skip
= move_it_in_display_line_to (it
, to_charpos
,
7448 if (skip
== MOVE_POS_MATCH_OR_ZV
)
7456 else if (op
& MOVE_TO_Y
)
7458 struct it it_backup
;
7460 if (it
->line_wrap
== WORD_WRAP
)
7463 /* TO_Y specified means stop at TO_X in the line containing
7464 TO_Y---or at TO_CHARPOS if this is reached first. The
7465 problem is that we can't really tell whether the line
7466 contains TO_Y before we have completely scanned it, and
7467 this may skip past TO_X. What we do is to first scan to
7470 If TO_X is not specified, use a TO_X of zero. The reason
7471 is to make the outcome of this function more predictable.
7472 If we didn't use TO_X == 0, we would stop at the end of
7473 the line which is probably not what a caller would expect
7475 skip
= move_it_in_display_line_to
7476 (it
, to_charpos
, ((op
& MOVE_TO_X
) ? to_x
: 0),
7477 (MOVE_TO_X
| (op
& MOVE_TO_POS
)));
7479 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
7480 if (skip
== MOVE_POS_MATCH_OR_ZV
)
7482 else if (skip
== MOVE_X_REACHED
)
7484 /* If TO_X was reached, we want to know whether TO_Y is
7485 in the line. We know this is the case if the already
7486 scanned glyphs make the line tall enough. Otherwise,
7487 we must check by scanning the rest of the line. */
7488 line_height
= it
->max_ascent
+ it
->max_descent
;
7489 if (to_y
>= it
->current_y
7490 && to_y
< it
->current_y
+ line_height
)
7496 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
7497 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
7499 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
7500 line_height
= it
->max_ascent
+ it
->max_descent
;
7501 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
7503 if (to_y
>= it
->current_y
7504 && to_y
< it
->current_y
+ line_height
)
7506 /* If TO_Y is in this line and TO_X was reached
7507 above, we scanned too far. We have to restore
7508 IT's settings to the ones before skipping. */
7515 if (skip
== MOVE_POS_MATCH_OR_ZV
)
7521 /* Check whether TO_Y is in this line. */
7522 line_height
= it
->max_ascent
+ it
->max_descent
;
7523 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
7525 if (to_y
>= it
->current_y
7526 && to_y
< it
->current_y
+ line_height
)
7528 /* When word-wrap is on, TO_X may lie past the end
7529 of a wrapped line. Then it->current is the
7530 character on the next line, so backtrack to the
7531 space before the wrap point. */
7532 if (skip
== MOVE_LINE_CONTINUED
7533 && it
->line_wrap
== WORD_WRAP
)
7535 int prev_x
= max (it
->current_x
- 1, 0);
7537 skip
= move_it_in_display_line_to
7538 (it
, -1, prev_x
, MOVE_TO_X
);
7547 else if (BUFFERP (it
->object
)
7548 && (it
->method
== GET_FROM_BUFFER
7549 || it
->method
== GET_FROM_STRETCH
)
7550 && IT_CHARPOS (*it
) >= to_charpos
)
7551 skip
= MOVE_POS_MATCH_OR_ZV
;
7553 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
7557 case MOVE_POS_MATCH_OR_ZV
:
7561 case MOVE_NEWLINE_OR_CR
:
7562 set_iterator_to_next (it
, 1);
7563 it
->continuation_lines_width
= 0;
7566 case MOVE_LINE_TRUNCATED
:
7567 it
->continuation_lines_width
= 0;
7568 reseat_at_next_visible_line_start (it
, 0);
7569 if ((op
& MOVE_TO_POS
) != 0
7570 && IT_CHARPOS (*it
) > to_charpos
)
7577 case MOVE_LINE_CONTINUED
:
7578 /* For continued lines ending in a tab, some of the glyphs
7579 associated with the tab are displayed on the current
7580 line. Since it->current_x does not include these glyphs,
7581 we use it->last_visible_x instead. */
7584 it
->continuation_lines_width
+= it
->last_visible_x
;
7585 /* When moving by vpos, ensure that the iterator really
7586 advances to the next line (bug#847, bug#969). Fixme:
7587 do we need to do this in other circumstances? */
7588 if (it
->current_x
!= it
->last_visible_x
7589 && (op
& MOVE_TO_VPOS
)
7590 && !(op
& (MOVE_TO_X
| MOVE_TO_POS
)))
7592 line_start_x
= it
->current_x
+ it
->pixel_width
7593 - it
->last_visible_x
;
7594 set_iterator_to_next (it
, 0);
7598 it
->continuation_lines_width
+= it
->current_x
;
7605 /* Reset/increment for the next run. */
7606 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
7607 it
->current_x
= line_start_x
;
7610 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
7612 last_height
= it
->max_ascent
+ it
->max_descent
;
7613 last_max_ascent
= it
->max_ascent
;
7614 it
->max_ascent
= it
->max_descent
= 0;
7619 /* On text terminals, we may stop at the end of a line in the middle
7620 of a multi-character glyph. If the glyph itself is continued,
7621 i.e. it is actually displayed on the next line, don't treat this
7622 stopping point as valid; move to the next line instead (unless
7623 that brings us offscreen). */
7624 if (!FRAME_WINDOW_P (it
->f
)
7626 && IT_CHARPOS (*it
) == to_charpos
7627 && it
->what
== IT_CHARACTER
7629 && it
->line_wrap
== WINDOW_WRAP
7630 && it
->current_x
== it
->last_visible_x
- 1
7633 && it
->vpos
< XFASTINT (it
->w
->window_end_vpos
))
7635 it
->continuation_lines_width
+= it
->current_x
;
7636 it
->current_x
= it
->hpos
= it
->max_ascent
= it
->max_descent
= 0;
7637 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
7639 last_height
= it
->max_ascent
+ it
->max_descent
;
7640 last_max_ascent
= it
->max_ascent
;
7643 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
7647 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
7649 If DY > 0, move IT backward at least that many pixels. DY = 0
7650 means move IT backward to the preceding line start or BEGV. This
7651 function may move over more than DY pixels if IT->current_y - DY
7652 ends up in the middle of a line; in this case IT->current_y will be
7653 set to the top of the line moved to. */
7656 move_it_vertically_backward (struct it
*it
, int dy
)
7660 EMACS_INT start_pos
;
7665 start_pos
= IT_CHARPOS (*it
);
7667 /* Estimate how many newlines we must move back. */
7668 nlines
= max (1, dy
/ FRAME_LINE_HEIGHT (it
->f
));
7670 /* Set the iterator's position that many lines back. */
7671 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
7672 back_to_previous_visible_line_start (it
);
7674 /* Reseat the iterator here. When moving backward, we don't want
7675 reseat to skip forward over invisible text, set up the iterator
7676 to deliver from overlay strings at the new position etc. So,
7677 use reseat_1 here. */
7678 reseat_1 (it
, it
->current
.pos
, 1);
7680 /* We are now surely at a line start. */
7681 it
->current_x
= it
->hpos
= 0;
7682 it
->continuation_lines_width
= 0;
7684 /* Move forward and see what y-distance we moved. First move to the
7685 start of the next line so that we get its height. We need this
7686 height to be able to tell whether we reached the specified
7689 it2
.max_ascent
= it2
.max_descent
= 0;
7692 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
7693 MOVE_TO_POS
| MOVE_TO_VPOS
);
7695 while (!IT_POS_VALID_AFTER_MOVE_P (&it2
));
7696 xassert (IT_CHARPOS (*it
) >= BEGV
);
7699 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
7700 xassert (IT_CHARPOS (*it
) >= BEGV
);
7701 /* H is the actual vertical distance from the position in *IT
7702 and the starting position. */
7703 h
= it2
.current_y
- it
->current_y
;
7704 /* NLINES is the distance in number of lines. */
7705 nlines
= it2
.vpos
- it
->vpos
;
7707 /* Correct IT's y and vpos position
7708 so that they are relative to the starting point. */
7714 /* DY == 0 means move to the start of the screen line. The
7715 value of nlines is > 0 if continuation lines were involved. */
7717 move_it_by_lines (it
, nlines
);
7721 /* The y-position we try to reach, relative to *IT.
7722 Note that H has been subtracted in front of the if-statement. */
7723 int target_y
= it
->current_y
+ h
- dy
;
7724 int y0
= it3
.current_y
;
7725 int y1
= line_bottom_y (&it3
);
7726 int line_height
= y1
- y0
;
7728 /* If we did not reach target_y, try to move further backward if
7729 we can. If we moved too far backward, try to move forward. */
7730 if (target_y
< it
->current_y
7731 /* This is heuristic. In a window that's 3 lines high, with
7732 a line height of 13 pixels each, recentering with point
7733 on the bottom line will try to move -39/2 = 19 pixels
7734 backward. Try to avoid moving into the first line. */
7735 && (it
->current_y
- target_y
7736 > min (window_box_height (it
->w
), line_height
* 2 / 3))
7737 && IT_CHARPOS (*it
) > BEGV
)
7739 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
7740 target_y
- it
->current_y
));
7741 dy
= it
->current_y
- target_y
;
7742 goto move_further_back
;
7744 else if (target_y
>= it
->current_y
+ line_height
7745 && IT_CHARPOS (*it
) < ZV
)
7747 /* Should move forward by at least one line, maybe more.
7749 Note: Calling move_it_by_lines can be expensive on
7750 terminal frames, where compute_motion is used (via
7751 vmotion) to do the job, when there are very long lines
7752 and truncate-lines is nil. That's the reason for
7753 treating terminal frames specially here. */
7755 if (!FRAME_WINDOW_P (it
->f
))
7756 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
7761 move_it_by_lines (it
, 1);
7763 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
7770 /* Move IT by a specified amount of pixel lines DY. DY negative means
7771 move backwards. DY = 0 means move to start of screen line. At the
7772 end, IT will be on the start of a screen line. */
7775 move_it_vertically (struct it
*it
, int dy
)
7778 move_it_vertically_backward (it
, -dy
);
7781 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
7782 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
7783 MOVE_TO_POS
| MOVE_TO_Y
);
7784 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
7786 /* If buffer ends in ZV without a newline, move to the start of
7787 the line to satisfy the post-condition. */
7788 if (IT_CHARPOS (*it
) == ZV
7790 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
7791 move_it_by_lines (it
, 0);
7796 /* Move iterator IT past the end of the text line it is in. */
7799 move_it_past_eol (struct it
*it
)
7801 enum move_it_result rc
;
7803 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
7804 if (rc
== MOVE_NEWLINE_OR_CR
)
7805 set_iterator_to_next (it
, 0);
7809 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
7810 negative means move up. DVPOS == 0 means move to the start of the
7813 Optimization idea: If we would know that IT->f doesn't use
7814 a face with proportional font, we could be faster for
7815 truncate-lines nil. */
7818 move_it_by_lines (struct it
*it
, int dvpos
)
7821 /* The commented-out optimization uses vmotion on terminals. This
7822 gives bad results, because elements like it->what, on which
7823 callers such as pos_visible_p rely, aren't updated. */
7824 /* struct position pos;
7825 if (!FRAME_WINDOW_P (it->f))
7827 struct text_pos textpos;
7829 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
7830 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
7831 reseat (it, textpos, 1);
7832 it->vpos += pos.vpos;
7833 it->current_y += pos.vpos;
7839 /* DVPOS == 0 means move to the start of the screen line. */
7840 move_it_vertically_backward (it
, 0);
7841 xassert (it
->current_x
== 0 && it
->hpos
== 0);
7842 /* Let next call to line_bottom_y calculate real line height */
7847 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
7848 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
7849 move_it_to (it
, IT_CHARPOS (*it
) + 1, -1, -1, -1, MOVE_TO_POS
);
7854 EMACS_INT start_charpos
, i
;
7856 /* Start at the beginning of the screen line containing IT's
7857 position. This may actually move vertically backwards,
7858 in case of overlays, so adjust dvpos accordingly. */
7860 move_it_vertically_backward (it
, 0);
7863 /* Go back -DVPOS visible lines and reseat the iterator there. */
7864 start_charpos
= IT_CHARPOS (*it
);
7865 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > BEGV
; --i
)
7866 back_to_previous_visible_line_start (it
);
7867 reseat (it
, it
->current
.pos
, 1);
7869 /* Move further back if we end up in a string or an image. */
7870 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
7872 /* First try to move to start of display line. */
7874 move_it_vertically_backward (it
, 0);
7876 if (IT_POS_VALID_AFTER_MOVE_P (it
))
7878 /* If start of line is still in string or image,
7879 move further back. */
7880 back_to_previous_visible_line_start (it
);
7881 reseat (it
, it
->current
.pos
, 1);
7885 it
->current_x
= it
->hpos
= 0;
7887 /* Above call may have moved too far if continuation lines
7888 are involved. Scan forward and see if it did. */
7890 it2
.vpos
= it2
.current_y
= 0;
7891 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
7892 it
->vpos
-= it2
.vpos
;
7893 it
->current_y
-= it2
.current_y
;
7894 it
->current_x
= it
->hpos
= 0;
7896 /* If we moved too far back, move IT some lines forward. */
7897 if (it2
.vpos
> -dvpos
)
7899 int delta
= it2
.vpos
+ dvpos
;
7901 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
7902 /* Move back again if we got too far ahead. */
7903 if (IT_CHARPOS (*it
) >= start_charpos
)
7909 /* Return 1 if IT points into the middle of a display vector. */
7912 in_display_vector_p (struct it
*it
)
7914 return (it
->method
== GET_FROM_DISPLAY_VECTOR
7915 && it
->current
.dpvec_index
> 0
7916 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
7920 /***********************************************************************
7922 ***********************************************************************/
7925 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
7929 add_to_log (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
7931 Lisp_Object args
[3];
7932 Lisp_Object msg
, fmt
;
7935 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
7938 /* Do nothing if called asynchronously. Inserting text into
7939 a buffer may call after-change-functions and alike and
7940 that would means running Lisp asynchronously. */
7941 if (handling_signal
)
7945 GCPRO4 (fmt
, msg
, arg1
, arg2
);
7947 args
[0] = fmt
= build_string (format
);
7950 msg
= Fformat (3, args
);
7952 len
= SBYTES (msg
) + 1;
7953 SAFE_ALLOCA (buffer
, char *, len
);
7954 memcpy (buffer
, SDATA (msg
), len
);
7956 message_dolog (buffer
, len
- 1, 1, 0);
7963 /* Output a newline in the *Messages* buffer if "needs" one. */
7966 message_log_maybe_newline (void)
7968 if (message_log_need_newline
)
7969 message_dolog ("", 0, 1, 0);
7973 /* Add a string M of length NBYTES to the message log, optionally
7974 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
7975 nonzero, means interpret the contents of M as multibyte. This
7976 function calls low-level routines in order to bypass text property
7977 hooks, etc. which might not be safe to run.
7979 This may GC (insert may run before/after change hooks),
7980 so the buffer M must NOT point to a Lisp string. */
7983 message_dolog (const char *m
, EMACS_INT nbytes
, int nlflag
, int multibyte
)
7985 const unsigned char *msg
= (const unsigned char *) m
;
7987 if (!NILP (Vmemory_full
))
7990 if (!NILP (Vmessage_log_max
))
7992 struct buffer
*oldbuf
;
7993 Lisp_Object oldpoint
, oldbegv
, oldzv
;
7994 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
7995 EMACS_INT point_at_end
= 0;
7996 EMACS_INT zv_at_end
= 0;
7997 Lisp_Object old_deactivate_mark
, tem
;
7998 struct gcpro gcpro1
;
8000 old_deactivate_mark
= Vdeactivate_mark
;
8001 oldbuf
= current_buffer
;
8002 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
8003 BVAR (current_buffer
, undo_list
) = Qt
;
8005 oldpoint
= message_dolog_marker1
;
8006 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
8007 oldbegv
= message_dolog_marker2
;
8008 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
8009 oldzv
= message_dolog_marker3
;
8010 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
8011 GCPRO1 (old_deactivate_mark
);
8019 BEGV_BYTE
= BEG_BYTE
;
8022 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
8024 /* Insert the string--maybe converting multibyte to single byte
8025 or vice versa, so that all the text fits the buffer. */
8027 && NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8033 /* Convert a multibyte string to single-byte
8034 for the *Message* buffer. */
8035 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
8037 c
= string_char_and_length (msg
+ i
, &char_bytes
);
8038 work
[0] = (ASCII_CHAR_P (c
)
8040 : multibyte_char_to_unibyte (c
));
8041 insert_1_both (work
, 1, 1, 1, 0, 0);
8044 else if (! multibyte
8045 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8049 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
8050 /* Convert a single-byte string to multibyte
8051 for the *Message* buffer. */
8052 for (i
= 0; i
< nbytes
; i
++)
8055 MAKE_CHAR_MULTIBYTE (c
);
8056 char_bytes
= CHAR_STRING (c
, str
);
8057 insert_1_both ((char *) str
, 1, char_bytes
, 1, 0, 0);
8061 insert_1 (m
, nbytes
, 1, 0, 0);
8065 EMACS_INT this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
;
8066 unsigned long int dups
;
8067 insert_1 ("\n", 1, 1, 0, 0);
8069 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
8071 this_bol_byte
= PT_BYTE
;
8073 /* See if this line duplicates the previous one.
8074 If so, combine duplicates. */
8077 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
8079 prev_bol_byte
= PT_BYTE
;
8081 dups
= message_log_check_duplicate (prev_bol_byte
,
8085 del_range_both (prev_bol
, prev_bol_byte
,
8086 this_bol
, this_bol_byte
, 0);
8092 /* If you change this format, don't forget to also
8093 change message_log_check_duplicate. */
8094 sprintf (dupstr
, " [%lu times]", dups
);
8095 duplen
= strlen (dupstr
);
8096 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
8097 insert_1 (dupstr
, duplen
, 1, 0, 1);
8102 /* If we have more than the desired maximum number of lines
8103 in the *Messages* buffer now, delete the oldest ones.
8104 This is safe because we don't have undo in this buffer. */
8106 if (NATNUMP (Vmessage_log_max
))
8108 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
8109 -XFASTINT (Vmessage_log_max
) - 1, 0);
8110 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
8113 BEGV
= XMARKER (oldbegv
)->charpos
;
8114 BEGV_BYTE
= marker_byte_position (oldbegv
);
8123 ZV
= XMARKER (oldzv
)->charpos
;
8124 ZV_BYTE
= marker_byte_position (oldzv
);
8128 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
8130 /* We can't do Fgoto_char (oldpoint) because it will run some
8132 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
8133 XMARKER (oldpoint
)->bytepos
);
8136 unchain_marker (XMARKER (oldpoint
));
8137 unchain_marker (XMARKER (oldbegv
));
8138 unchain_marker (XMARKER (oldzv
));
8140 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
8141 set_buffer_internal (oldbuf
);
8143 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
8144 message_log_need_newline
= !nlflag
;
8145 Vdeactivate_mark
= old_deactivate_mark
;
8150 /* We are at the end of the buffer after just having inserted a newline.
8151 (Note: We depend on the fact we won't be crossing the gap.)
8152 Check to see if the most recent message looks a lot like the previous one.
8153 Return 0 if different, 1 if the new one should just replace it, or a
8154 value N > 1 if we should also append " [N times]". */
8156 static unsigned long int
8157 message_log_check_duplicate (EMACS_INT prev_bol_byte
, EMACS_INT this_bol_byte
)
8160 EMACS_INT len
= Z_BYTE
- 1 - this_bol_byte
;
8162 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
8163 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
8165 for (i
= 0; i
< len
; i
++)
8167 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
8175 if (*p1
++ == ' ' && *p1
++ == '[')
8178 unsigned long int n
= strtoul ((char *) p1
, &pend
, 10);
8179 if (strncmp (pend
, " times]\n", 8) == 0)
8186 /* Display an echo area message M with a specified length of NBYTES
8187 bytes. The string may include null characters. If M is 0, clear
8188 out any existing message, and let the mini-buffer text show
8191 This may GC, so the buffer M must NOT point to a Lisp string. */
8194 message2 (const char *m
, EMACS_INT nbytes
, int multibyte
)
8196 /* First flush out any partial line written with print. */
8197 message_log_maybe_newline ();
8199 message_dolog (m
, nbytes
, 1, multibyte
);
8200 message2_nolog (m
, nbytes
, multibyte
);
8204 /* The non-logging counterpart of message2. */
8207 message2_nolog (const char *m
, EMACS_INT nbytes
, int multibyte
)
8209 struct frame
*sf
= SELECTED_FRAME ();
8210 message_enable_multibyte
= multibyte
;
8212 if (FRAME_INITIAL_P (sf
))
8214 if (noninteractive_need_newline
)
8215 putc ('\n', stderr
);
8216 noninteractive_need_newline
= 0;
8218 fwrite (m
, nbytes
, 1, stderr
);
8219 if (cursor_in_echo_area
== 0)
8220 fprintf (stderr
, "\n");
8223 /* A null message buffer means that the frame hasn't really been
8224 initialized yet. Error messages get reported properly by
8225 cmd_error, so this must be just an informative message; toss it. */
8226 else if (INTERACTIVE
8227 && sf
->glyphs_initialized_p
8228 && FRAME_MESSAGE_BUF (sf
))
8230 Lisp_Object mini_window
;
8233 /* Get the frame containing the mini-buffer
8234 that the selected frame is using. */
8235 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8236 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8238 FRAME_SAMPLE_VISIBILITY (f
);
8239 if (FRAME_VISIBLE_P (sf
)
8240 && ! FRAME_VISIBLE_P (f
))
8241 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
8245 set_message (m
, Qnil
, nbytes
, multibyte
);
8246 if (minibuffer_auto_raise
)
8247 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
8250 clear_message (1, 1);
8252 do_pending_window_change (0);
8253 echo_area_display (1);
8254 do_pending_window_change (0);
8255 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
8256 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
8261 /* Display an echo area message M with a specified length of NBYTES
8262 bytes. The string may include null characters. If M is not a
8263 string, clear out any existing message, and let the mini-buffer
8266 This function cancels echoing. */
8269 message3 (Lisp_Object m
, EMACS_INT nbytes
, int multibyte
)
8271 struct gcpro gcpro1
;
8274 clear_message (1,1);
8277 /* First flush out any partial line written with print. */
8278 message_log_maybe_newline ();
8284 SAFE_ALLOCA (buffer
, char *, nbytes
);
8285 memcpy (buffer
, SDATA (m
), nbytes
);
8286 message_dolog (buffer
, nbytes
, 1, multibyte
);
8289 message3_nolog (m
, nbytes
, multibyte
);
8295 /* The non-logging version of message3.
8296 This does not cancel echoing, because it is used for echoing.
8297 Perhaps we need to make a separate function for echoing
8298 and make this cancel echoing. */
8301 message3_nolog (Lisp_Object m
, EMACS_INT nbytes
, int multibyte
)
8303 struct frame
*sf
= SELECTED_FRAME ();
8304 message_enable_multibyte
= multibyte
;
8306 if (FRAME_INITIAL_P (sf
))
8308 if (noninteractive_need_newline
)
8309 putc ('\n', stderr
);
8310 noninteractive_need_newline
= 0;
8312 fwrite (SDATA (m
), nbytes
, 1, stderr
);
8313 if (cursor_in_echo_area
== 0)
8314 fprintf (stderr
, "\n");
8317 /* A null message buffer means that the frame hasn't really been
8318 initialized yet. Error messages get reported properly by
8319 cmd_error, so this must be just an informative message; toss it. */
8320 else if (INTERACTIVE
8321 && sf
->glyphs_initialized_p
8322 && FRAME_MESSAGE_BUF (sf
))
8324 Lisp_Object mini_window
;
8328 /* Get the frame containing the mini-buffer
8329 that the selected frame is using. */
8330 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8331 frame
= XWINDOW (mini_window
)->frame
;
8334 FRAME_SAMPLE_VISIBILITY (f
);
8335 if (FRAME_VISIBLE_P (sf
)
8336 && !FRAME_VISIBLE_P (f
))
8337 Fmake_frame_visible (frame
);
8339 if (STRINGP (m
) && SCHARS (m
) > 0)
8341 set_message (NULL
, m
, nbytes
, multibyte
);
8342 if (minibuffer_auto_raise
)
8343 Fraise_frame (frame
);
8344 /* Assume we are not echoing.
8345 (If we are, echo_now will override this.) */
8346 echo_message_buffer
= Qnil
;
8349 clear_message (1, 1);
8351 do_pending_window_change (0);
8352 echo_area_display (1);
8353 do_pending_window_change (0);
8354 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
8355 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
8360 /* Display a null-terminated echo area message M. If M is 0, clear
8361 out any existing message, and let the mini-buffer text show through.
8363 The buffer M must continue to exist until after the echo area gets
8364 cleared or some other message gets displayed there. Do not pass
8365 text that is stored in a Lisp string. Do not pass text in a buffer
8366 that was alloca'd. */
8369 message1 (const char *m
)
8371 message2 (m
, (m
? strlen (m
) : 0), 0);
8375 /* The non-logging counterpart of message1. */
8378 message1_nolog (const char *m
)
8380 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
8383 /* Display a message M which contains a single %s
8384 which gets replaced with STRING. */
8387 message_with_string (const char *m
, Lisp_Object string
, int log
)
8389 CHECK_STRING (string
);
8395 if (noninteractive_need_newline
)
8396 putc ('\n', stderr
);
8397 noninteractive_need_newline
= 0;
8398 fprintf (stderr
, m
, SDATA (string
));
8399 if (!cursor_in_echo_area
)
8400 fprintf (stderr
, "\n");
8404 else if (INTERACTIVE
)
8406 /* The frame whose minibuffer we're going to display the message on.
8407 It may be larger than the selected frame, so we need
8408 to use its buffer, not the selected frame's buffer. */
8409 Lisp_Object mini_window
;
8410 struct frame
*f
, *sf
= SELECTED_FRAME ();
8412 /* Get the frame containing the minibuffer
8413 that the selected frame is using. */
8414 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8415 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8417 /* A null message buffer means that the frame hasn't really been
8418 initialized yet. Error messages get reported properly by
8419 cmd_error, so this must be just an informative message; toss it. */
8420 if (FRAME_MESSAGE_BUF (f
))
8422 Lisp_Object args
[2], msg
;
8423 struct gcpro gcpro1
, gcpro2
;
8425 args
[0] = build_string (m
);
8426 args
[1] = msg
= string
;
8427 GCPRO2 (args
[0], msg
);
8430 msg
= Fformat (2, args
);
8433 message3 (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
8435 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
8439 /* Print should start at the beginning of the message
8440 buffer next time. */
8441 message_buf_print
= 0;
8447 /* Dump an informative message to the minibuf. If M is 0, clear out
8448 any existing message, and let the mini-buffer text show through. */
8451 vmessage (const char *m
, va_list ap
)
8457 if (noninteractive_need_newline
)
8458 putc ('\n', stderr
);
8459 noninteractive_need_newline
= 0;
8460 vfprintf (stderr
, m
, ap
);
8461 if (cursor_in_echo_area
== 0)
8462 fprintf (stderr
, "\n");
8466 else if (INTERACTIVE
)
8468 /* The frame whose mini-buffer we're going to display the message
8469 on. It may be larger than the selected frame, so we need to
8470 use its buffer, not the selected frame's buffer. */
8471 Lisp_Object mini_window
;
8472 struct frame
*f
, *sf
= SELECTED_FRAME ();
8474 /* Get the frame containing the mini-buffer
8475 that the selected frame is using. */
8476 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8477 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8479 /* A null message buffer means that the frame hasn't really been
8480 initialized yet. Error messages get reported properly by
8481 cmd_error, so this must be just an informative message; toss
8483 if (FRAME_MESSAGE_BUF (f
))
8489 len
= doprnt (FRAME_MESSAGE_BUF (f
),
8490 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, ap
);
8492 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
8497 /* Print should start at the beginning of the message
8498 buffer next time. */
8499 message_buf_print
= 0;
8505 message (const char *m
, ...)
8515 /* The non-logging version of message. */
8518 message_nolog (const char *m
, ...)
8520 Lisp_Object old_log_max
;
8523 old_log_max
= Vmessage_log_max
;
8524 Vmessage_log_max
= Qnil
;
8526 Vmessage_log_max
= old_log_max
;
8532 /* Display the current message in the current mini-buffer. This is
8533 only called from error handlers in process.c, and is not time
8537 update_echo_area (void)
8539 if (!NILP (echo_area_buffer
[0]))
8542 string
= Fcurrent_message ();
8543 message3 (string
, SBYTES (string
),
8544 !NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
8549 /* Make sure echo area buffers in `echo_buffers' are live.
8550 If they aren't, make new ones. */
8553 ensure_echo_area_buffers (void)
8557 for (i
= 0; i
< 2; ++i
)
8558 if (!BUFFERP (echo_buffer
[i
])
8559 || NILP (BVAR (XBUFFER (echo_buffer
[i
]), name
)))
8562 Lisp_Object old_buffer
;
8565 old_buffer
= echo_buffer
[i
];
8566 sprintf (name
, " *Echo Area %d*", i
);
8567 echo_buffer
[i
] = Fget_buffer_create (build_string (name
));
8568 BVAR (XBUFFER (echo_buffer
[i
]), truncate_lines
) = Qnil
;
8569 /* to force word wrap in echo area -
8570 it was decided to postpone this*/
8571 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
8573 for (j
= 0; j
< 2; ++j
)
8574 if (EQ (old_buffer
, echo_area_buffer
[j
]))
8575 echo_area_buffer
[j
] = echo_buffer
[i
];
8580 /* Call FN with args A1..A4 with either the current or last displayed
8581 echo_area_buffer as current buffer.
8583 WHICH zero means use the current message buffer
8584 echo_area_buffer[0]. If that is nil, choose a suitable buffer
8585 from echo_buffer[] and clear it.
8587 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
8588 suitable buffer from echo_buffer[] and clear it.
8590 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
8591 that the current message becomes the last displayed one, make
8592 choose a suitable buffer for echo_area_buffer[0], and clear it.
8594 Value is what FN returns. */
8597 with_echo_area_buffer (struct window
*w
, int which
,
8598 int (*fn
) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
8599 EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
8602 int this_one
, the_other
, clear_buffer_p
, rc
;
8603 int count
= SPECPDL_INDEX ();
8605 /* If buffers aren't live, make new ones. */
8606 ensure_echo_area_buffers ();
8611 this_one
= 0, the_other
= 1;
8613 this_one
= 1, the_other
= 0;
8616 this_one
= 0, the_other
= 1;
8619 /* We need a fresh one in case the current echo buffer equals
8620 the one containing the last displayed echo area message. */
8621 if (!NILP (echo_area_buffer
[this_one
])
8622 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
8623 echo_area_buffer
[this_one
] = Qnil
;
8626 /* Choose a suitable buffer from echo_buffer[] is we don't
8628 if (NILP (echo_area_buffer
[this_one
]))
8630 echo_area_buffer
[this_one
]
8631 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
8632 ? echo_buffer
[the_other
]
8633 : echo_buffer
[this_one
]);
8637 buffer
= echo_area_buffer
[this_one
];
8639 /* Don't get confused by reusing the buffer used for echoing
8640 for a different purpose. */
8641 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
8644 record_unwind_protect (unwind_with_echo_area_buffer
,
8645 with_echo_area_buffer_unwind_data (w
));
8647 /* Make the echo area buffer current. Note that for display
8648 purposes, it is not necessary that the displayed window's buffer
8649 == current_buffer, except for text property lookup. So, let's
8650 only set that buffer temporarily here without doing a full
8651 Fset_window_buffer. We must also change w->pointm, though,
8652 because otherwise an assertions in unshow_buffer fails, and Emacs
8654 set_buffer_internal_1 (XBUFFER (buffer
));
8658 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
8661 BVAR (current_buffer
, undo_list
) = Qt
;
8662 BVAR (current_buffer
, read_only
) = Qnil
;
8663 specbind (Qinhibit_read_only
, Qt
);
8664 specbind (Qinhibit_modification_hooks
, Qt
);
8666 if (clear_buffer_p
&& Z
> BEG
)
8669 xassert (BEGV
>= BEG
);
8670 xassert (ZV
<= Z
&& ZV
>= BEGV
);
8672 rc
= fn (a1
, a2
, a3
, a4
);
8674 xassert (BEGV
>= BEG
);
8675 xassert (ZV
<= Z
&& ZV
>= BEGV
);
8677 unbind_to (count
, Qnil
);
8682 /* Save state that should be preserved around the call to the function
8683 FN called in with_echo_area_buffer. */
8686 with_echo_area_buffer_unwind_data (struct window
*w
)
8689 Lisp_Object vector
, tmp
;
8691 /* Reduce consing by keeping one vector in
8692 Vwith_echo_area_save_vector. */
8693 vector
= Vwith_echo_area_save_vector
;
8694 Vwith_echo_area_save_vector
= Qnil
;
8697 vector
= Fmake_vector (make_number (7), Qnil
);
8699 XSETBUFFER (tmp
, current_buffer
); ASET (vector
, i
, tmp
); ++i
;
8700 ASET (vector
, i
, Vdeactivate_mark
); ++i
;
8701 ASET (vector
, i
, make_number (windows_or_buffers_changed
)); ++i
;
8705 XSETWINDOW (tmp
, w
); ASET (vector
, i
, tmp
); ++i
;
8706 ASET (vector
, i
, w
->buffer
); ++i
;
8707 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->charpos
)); ++i
;
8708 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->bytepos
)); ++i
;
8713 for (; i
< end
; ++i
)
8714 ASET (vector
, i
, Qnil
);
8717 xassert (i
== ASIZE (vector
));
8722 /* Restore global state from VECTOR which was created by
8723 with_echo_area_buffer_unwind_data. */
8726 unwind_with_echo_area_buffer (Lisp_Object vector
)
8728 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
8729 Vdeactivate_mark
= AREF (vector
, 1);
8730 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
8732 if (WINDOWP (AREF (vector
, 3)))
8735 Lisp_Object buffer
, charpos
, bytepos
;
8737 w
= XWINDOW (AREF (vector
, 3));
8738 buffer
= AREF (vector
, 4);
8739 charpos
= AREF (vector
, 5);
8740 bytepos
= AREF (vector
, 6);
8743 set_marker_both (w
->pointm
, buffer
,
8744 XFASTINT (charpos
), XFASTINT (bytepos
));
8747 Vwith_echo_area_save_vector
= vector
;
8752 /* Set up the echo area for use by print functions. MULTIBYTE_P
8753 non-zero means we will print multibyte. */
8756 setup_echo_area_for_printing (int multibyte_p
)
8758 /* If we can't find an echo area any more, exit. */
8759 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8762 ensure_echo_area_buffers ();
8764 if (!message_buf_print
)
8766 /* A message has been output since the last time we printed.
8767 Choose a fresh echo area buffer. */
8768 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
8769 echo_area_buffer
[0] = echo_buffer
[1];
8771 echo_area_buffer
[0] = echo_buffer
[0];
8773 /* Switch to that buffer and clear it. */
8774 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
8775 BVAR (current_buffer
, truncate_lines
) = Qnil
;
8779 int count
= SPECPDL_INDEX ();
8780 specbind (Qinhibit_read_only
, Qt
);
8781 /* Note that undo recording is always disabled. */
8783 unbind_to (count
, Qnil
);
8785 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
8787 /* Set up the buffer for the multibyteness we need. */
8789 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8790 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
8792 /* Raise the frame containing the echo area. */
8793 if (minibuffer_auto_raise
)
8795 struct frame
*sf
= SELECTED_FRAME ();
8796 Lisp_Object mini_window
;
8797 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8798 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
8801 message_log_maybe_newline ();
8802 message_buf_print
= 1;
8806 if (NILP (echo_area_buffer
[0]))
8808 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
8809 echo_area_buffer
[0] = echo_buffer
[1];
8811 echo_area_buffer
[0] = echo_buffer
[0];
8814 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
8816 /* Someone switched buffers between print requests. */
8817 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
8818 BVAR (current_buffer
, truncate_lines
) = Qnil
;
8824 /* Display an echo area message in window W. Value is non-zero if W's
8825 height is changed. If display_last_displayed_message_p is
8826 non-zero, display the message that was last displayed, otherwise
8827 display the current message. */
8830 display_echo_area (struct window
*w
)
8832 int i
, no_message_p
, window_height_changed_p
, count
;
8834 /* Temporarily disable garbage collections while displaying the echo
8835 area. This is done because a GC can print a message itself.
8836 That message would modify the echo area buffer's contents while a
8837 redisplay of the buffer is going on, and seriously confuse
8839 count
= inhibit_garbage_collection ();
8841 /* If there is no message, we must call display_echo_area_1
8842 nevertheless because it resizes the window. But we will have to
8843 reset the echo_area_buffer in question to nil at the end because
8844 with_echo_area_buffer will sets it to an empty buffer. */
8845 i
= display_last_displayed_message_p
? 1 : 0;
8846 no_message_p
= NILP (echo_area_buffer
[i
]);
8848 window_height_changed_p
8849 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
8850 display_echo_area_1
,
8851 (intptr_t) w
, Qnil
, 0, 0);
8854 echo_area_buffer
[i
] = Qnil
;
8856 unbind_to (count
, Qnil
);
8857 return window_height_changed_p
;
8861 /* Helper for display_echo_area. Display the current buffer which
8862 contains the current echo area message in window W, a mini-window,
8863 a pointer to which is passed in A1. A2..A4 are currently not used.
8864 Change the height of W so that all of the message is displayed.
8865 Value is non-zero if height of W was changed. */
8868 display_echo_area_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
8871 struct window
*w
= (struct window
*) i1
;
8873 struct text_pos start
;
8874 int window_height_changed_p
= 0;
8876 /* Do this before displaying, so that we have a large enough glyph
8877 matrix for the display. If we can't get enough space for the
8878 whole text, display the last N lines. That works by setting w->start. */
8879 window_height_changed_p
= resize_mini_window (w
, 0);
8881 /* Use the starting position chosen by resize_mini_window. */
8882 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
8885 clear_glyph_matrix (w
->desired_matrix
);
8886 XSETWINDOW (window
, w
);
8887 try_window (window
, start
, 0);
8889 return window_height_changed_p
;
8893 /* Resize the echo area window to exactly the size needed for the
8894 currently displayed message, if there is one. If a mini-buffer
8895 is active, don't shrink it. */
8898 resize_echo_area_exactly (void)
8900 if (BUFFERP (echo_area_buffer
[0])
8901 && WINDOWP (echo_area_window
))
8903 struct window
*w
= XWINDOW (echo_area_window
);
8905 Lisp_Object resize_exactly
;
8907 if (minibuf_level
== 0)
8908 resize_exactly
= Qt
;
8910 resize_exactly
= Qnil
;
8912 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
8913 (intptr_t) w
, resize_exactly
,
8917 ++windows_or_buffers_changed
;
8918 ++update_mode_lines
;
8919 redisplay_internal ();
8925 /* Callback function for with_echo_area_buffer, when used from
8926 resize_echo_area_exactly. A1 contains a pointer to the window to
8927 resize, EXACTLY non-nil means resize the mini-window exactly to the
8928 size of the text displayed. A3 and A4 are not used. Value is what
8929 resize_mini_window returns. */
8932 resize_mini_window_1 (EMACS_INT a1
, Lisp_Object exactly
, EMACS_INT a3
, EMACS_INT a4
)
8935 return resize_mini_window ((struct window
*) i1
, !NILP (exactly
));
8939 /* Resize mini-window W to fit the size of its contents. EXACT_P
8940 means size the window exactly to the size needed. Otherwise, it's
8941 only enlarged until W's buffer is empty.
8943 Set W->start to the right place to begin display. If the whole
8944 contents fit, start at the beginning. Otherwise, start so as
8945 to make the end of the contents appear. This is particularly
8946 important for y-or-n-p, but seems desirable generally.
8948 Value is non-zero if the window height has been changed. */
8951 resize_mini_window (struct window
*w
, int exact_p
)
8953 struct frame
*f
= XFRAME (w
->frame
);
8954 int window_height_changed_p
= 0;
8956 xassert (MINI_WINDOW_P (w
));
8958 /* By default, start display at the beginning. */
8959 set_marker_both (w
->start
, w
->buffer
,
8960 BUF_BEGV (XBUFFER (w
->buffer
)),
8961 BUF_BEGV_BYTE (XBUFFER (w
->buffer
)));
8963 /* Don't resize windows while redisplaying a window; it would
8964 confuse redisplay functions when the size of the window they are
8965 displaying changes from under them. Such a resizing can happen,
8966 for instance, when which-func prints a long message while
8967 we are running fontification-functions. We're running these
8968 functions with safe_call which binds inhibit-redisplay to t. */
8969 if (!NILP (Vinhibit_redisplay
))
8972 /* Nil means don't try to resize. */
8973 if (NILP (Vresize_mini_windows
)
8974 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
8977 if (!FRAME_MINIBUF_ONLY_P (f
))
8980 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
8981 int total_height
= WINDOW_TOTAL_LINES (root
) + WINDOW_TOTAL_LINES (w
);
8982 int height
, max_height
;
8983 int unit
= FRAME_LINE_HEIGHT (f
);
8984 struct text_pos start
;
8985 struct buffer
*old_current_buffer
= NULL
;
8987 if (current_buffer
!= XBUFFER (w
->buffer
))
8989 old_current_buffer
= current_buffer
;
8990 set_buffer_internal (XBUFFER (w
->buffer
));
8993 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
8995 /* Compute the max. number of lines specified by the user. */
8996 if (FLOATP (Vmax_mini_window_height
))
8997 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_LINES (f
);
8998 else if (INTEGERP (Vmax_mini_window_height
))
8999 max_height
= XINT (Vmax_mini_window_height
);
9001 max_height
= total_height
/ 4;
9003 /* Correct that max. height if it's bogus. */
9004 max_height
= max (1, max_height
);
9005 max_height
= min (total_height
, max_height
);
9007 /* Find out the height of the text in the window. */
9008 if (it
.line_wrap
== TRUNCATE
)
9013 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
9014 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
9015 height
= it
.current_y
+ last_height
;
9017 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
9018 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
9019 height
= (height
+ unit
- 1) / unit
;
9022 /* Compute a suitable window start. */
9023 if (height
> max_height
)
9025 height
= max_height
;
9026 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
9027 move_it_vertically_backward (&it
, (height
- 1) * unit
);
9028 start
= it
.current
.pos
;
9031 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
9032 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
9034 if (EQ (Vresize_mini_windows
, Qgrow_only
))
9036 /* Let it grow only, until we display an empty message, in which
9037 case the window shrinks again. */
9038 if (height
> WINDOW_TOTAL_LINES (w
))
9040 int old_height
= WINDOW_TOTAL_LINES (w
);
9041 freeze_window_starts (f
, 1);
9042 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9043 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9045 else if (height
< WINDOW_TOTAL_LINES (w
)
9046 && (exact_p
|| BEGV
== ZV
))
9048 int old_height
= WINDOW_TOTAL_LINES (w
);
9049 freeze_window_starts (f
, 0);
9050 shrink_mini_window (w
);
9051 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9056 /* Always resize to exact size needed. */
9057 if (height
> WINDOW_TOTAL_LINES (w
))
9059 int old_height
= WINDOW_TOTAL_LINES (w
);
9060 freeze_window_starts (f
, 1);
9061 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9062 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9064 else if (height
< WINDOW_TOTAL_LINES (w
))
9066 int old_height
= WINDOW_TOTAL_LINES (w
);
9067 freeze_window_starts (f
, 0);
9068 shrink_mini_window (w
);
9072 freeze_window_starts (f
, 1);
9073 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9076 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9080 if (old_current_buffer
)
9081 set_buffer_internal (old_current_buffer
);
9084 return window_height_changed_p
;
9088 /* Value is the current message, a string, or nil if there is no
9092 current_message (void)
9096 if (!BUFFERP (echo_area_buffer
[0]))
9100 with_echo_area_buffer (0, 0, current_message_1
,
9101 (intptr_t) &msg
, Qnil
, 0, 0);
9103 echo_area_buffer
[0] = Qnil
;
9111 current_message_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9114 Lisp_Object
*msg
= (Lisp_Object
*) i1
;
9117 *msg
= make_buffer_string (BEG
, Z
, 1);
9124 /* Push the current message on Vmessage_stack for later restauration
9125 by restore_message. Value is non-zero if the current message isn't
9126 empty. This is a relatively infrequent operation, so it's not
9127 worth optimizing. */
9133 msg
= current_message ();
9134 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
9135 return STRINGP (msg
);
9139 /* Restore message display from the top of Vmessage_stack. */
9142 restore_message (void)
9146 xassert (CONSP (Vmessage_stack
));
9147 msg
= XCAR (Vmessage_stack
);
9149 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9151 message3_nolog (msg
, 0, 0);
9155 /* Handler for record_unwind_protect calling pop_message. */
9158 pop_message_unwind (Lisp_Object dummy
)
9164 /* Pop the top-most entry off Vmessage_stack. */
9169 xassert (CONSP (Vmessage_stack
));
9170 Vmessage_stack
= XCDR (Vmessage_stack
);
9174 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
9175 exits. If the stack is not empty, we have a missing pop_message
9179 check_message_stack (void)
9181 if (!NILP (Vmessage_stack
))
9186 /* Truncate to NCHARS what will be displayed in the echo area the next
9187 time we display it---but don't redisplay it now. */
9190 truncate_echo_area (EMACS_INT nchars
)
9193 echo_area_buffer
[0] = Qnil
;
9194 /* A null message buffer means that the frame hasn't really been
9195 initialized yet. Error messages get reported properly by
9196 cmd_error, so this must be just an informative message; toss it. */
9197 else if (!noninteractive
9199 && !NILP (echo_area_buffer
[0]))
9201 struct frame
*sf
= SELECTED_FRAME ();
9202 if (FRAME_MESSAGE_BUF (sf
))
9203 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
9208 /* Helper function for truncate_echo_area. Truncate the current
9209 message to at most NCHARS characters. */
9212 truncate_message_1 (EMACS_INT nchars
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9214 if (BEG
+ nchars
< Z
)
9215 del_range (BEG
+ nchars
, Z
);
9217 echo_area_buffer
[0] = Qnil
;
9222 /* Set the current message to a substring of S or STRING.
9224 If STRING is a Lisp string, set the message to the first NBYTES
9225 bytes from STRING. NBYTES zero means use the whole string. If
9226 STRING is multibyte, the message will be displayed multibyte.
9228 If S is not null, set the message to the first LEN bytes of S. LEN
9229 zero means use the whole string. MULTIBYTE_P non-zero means S is
9230 multibyte. Display the message multibyte in that case.
9232 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
9233 to t before calling set_message_1 (which calls insert).
9237 set_message (const char *s
, Lisp_Object string
,
9238 EMACS_INT nbytes
, int multibyte_p
)
9240 message_enable_multibyte
9241 = ((s
&& multibyte_p
)
9242 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
9244 with_echo_area_buffer (0, -1, set_message_1
,
9245 (intptr_t) s
, string
, nbytes
, multibyte_p
);
9246 message_buf_print
= 0;
9247 help_echo_showing_p
= 0;
9251 /* Helper function for set_message. Arguments have the same meaning
9252 as there, with A1 corresponding to S and A2 corresponding to STRING
9253 This function is called with the echo area buffer being
9257 set_message_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT nbytes
, EMACS_INT multibyte_p
)
9260 const char *s
= (const char *) i1
;
9261 const unsigned char *msg
= (const unsigned char *) s
;
9262 Lisp_Object string
= a2
;
9264 /* Change multibyteness of the echo buffer appropriately. */
9265 if (message_enable_multibyte
9266 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9267 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
9269 BVAR (current_buffer
, truncate_lines
) = message_truncate_lines
? Qt
: Qnil
;
9270 if (!NILP (BVAR (current_buffer
, bidi_display_reordering
)))
9271 BVAR (current_buffer
, bidi_paragraph_direction
) = Qleft_to_right
;
9273 /* Insert new message at BEG. */
9274 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
9276 if (STRINGP (string
))
9281 nbytes
= SBYTES (string
);
9282 nchars
= string_byte_to_char (string
, nbytes
);
9284 /* This function takes care of single/multibyte conversion. We
9285 just have to ensure that the echo area buffer has the right
9286 setting of enable_multibyte_characters. */
9287 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
9292 nbytes
= strlen (s
);
9294 if (multibyte_p
&& NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9296 /* Convert from multi-byte to single-byte. */
9301 /* Convert a multibyte string to single-byte. */
9302 for (i
= 0; i
< nbytes
; i
+= n
)
9304 c
= string_char_and_length (msg
+ i
, &n
);
9305 work
[0] = (ASCII_CHAR_P (c
)
9307 : multibyte_char_to_unibyte (c
));
9308 insert_1_both (work
, 1, 1, 1, 0, 0);
9311 else if (!multibyte_p
9312 && !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9314 /* Convert from single-byte to multi-byte. */
9317 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
9319 /* Convert a single-byte string to multibyte. */
9320 for (i
= 0; i
< nbytes
; i
++)
9323 MAKE_CHAR_MULTIBYTE (c
);
9324 n
= CHAR_STRING (c
, str
);
9325 insert_1_both ((char *) str
, 1, n
, 1, 0, 0);
9329 insert_1 (s
, nbytes
, 1, 0, 0);
9336 /* Clear messages. CURRENT_P non-zero means clear the current
9337 message. LAST_DISPLAYED_P non-zero means clear the message
9341 clear_message (int current_p
, int last_displayed_p
)
9345 echo_area_buffer
[0] = Qnil
;
9346 message_cleared_p
= 1;
9349 if (last_displayed_p
)
9350 echo_area_buffer
[1] = Qnil
;
9352 message_buf_print
= 0;
9355 /* Clear garbaged frames.
9357 This function is used where the old redisplay called
9358 redraw_garbaged_frames which in turn called redraw_frame which in
9359 turn called clear_frame. The call to clear_frame was a source of
9360 flickering. I believe a clear_frame is not necessary. It should
9361 suffice in the new redisplay to invalidate all current matrices,
9362 and ensure a complete redisplay of all windows. */
9365 clear_garbaged_frames (void)
9369 Lisp_Object tail
, frame
;
9370 int changed_count
= 0;
9372 FOR_EACH_FRAME (tail
, frame
)
9374 struct frame
*f
= XFRAME (frame
);
9376 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
9380 Fredraw_frame (frame
);
9381 f
->force_flush_display_p
= 1;
9383 clear_current_matrices (f
);
9392 ++windows_or_buffers_changed
;
9397 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
9398 is non-zero update selected_frame. Value is non-zero if the
9399 mini-windows height has been changed. */
9402 echo_area_display (int update_frame_p
)
9404 Lisp_Object mini_window
;
9407 int window_height_changed_p
= 0;
9408 struct frame
*sf
= SELECTED_FRAME ();
9410 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9411 w
= XWINDOW (mini_window
);
9412 f
= XFRAME (WINDOW_FRAME (w
));
9414 /* Don't display if frame is invisible or not yet initialized. */
9415 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
9418 #ifdef HAVE_WINDOW_SYSTEM
9419 /* When Emacs starts, selected_frame may be the initial terminal
9420 frame. If we let this through, a message would be displayed on
9422 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
9424 #endif /* HAVE_WINDOW_SYSTEM */
9426 /* Redraw garbaged frames. */
9428 clear_garbaged_frames ();
9430 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
9432 echo_area_window
= mini_window
;
9433 window_height_changed_p
= display_echo_area (w
);
9434 w
->must_be_updated_p
= 1;
9436 /* Update the display, unless called from redisplay_internal.
9437 Also don't update the screen during redisplay itself. The
9438 update will happen at the end of redisplay, and an update
9439 here could cause confusion. */
9440 if (update_frame_p
&& !redisplaying_p
)
9444 /* If the display update has been interrupted by pending
9445 input, update mode lines in the frame. Due to the
9446 pending input, it might have been that redisplay hasn't
9447 been called, so that mode lines above the echo area are
9448 garbaged. This looks odd, so we prevent it here. */
9449 if (!display_completed
)
9450 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
9452 if (window_height_changed_p
9453 /* Don't do this if Emacs is shutting down. Redisplay
9454 needs to run hooks. */
9455 && !NILP (Vrun_hooks
))
9457 /* Must update other windows. Likewise as in other
9458 cases, don't let this update be interrupted by
9460 int count
= SPECPDL_INDEX ();
9461 specbind (Qredisplay_dont_pause
, Qt
);
9462 windows_or_buffers_changed
= 1;
9463 redisplay_internal ();
9464 unbind_to (count
, Qnil
);
9466 else if (FRAME_WINDOW_P (f
) && n
== 0)
9468 /* Window configuration is the same as before.
9469 Can do with a display update of the echo area,
9470 unless we displayed some mode lines. */
9471 update_single_window (w
, 1);
9472 FRAME_RIF (f
)->flush_display (f
);
9475 update_frame (f
, 1, 1);
9477 /* If cursor is in the echo area, make sure that the next
9478 redisplay displays the minibuffer, so that the cursor will
9479 be replaced with what the minibuffer wants. */
9480 if (cursor_in_echo_area
)
9481 ++windows_or_buffers_changed
;
9484 else if (!EQ (mini_window
, selected_window
))
9485 windows_or_buffers_changed
++;
9487 /* Last displayed message is now the current message. */
9488 echo_area_buffer
[1] = echo_area_buffer
[0];
9489 /* Inform read_char that we're not echoing. */
9490 echo_message_buffer
= Qnil
;
9492 /* Prevent redisplay optimization in redisplay_internal by resetting
9493 this_line_start_pos. This is done because the mini-buffer now
9494 displays the message instead of its buffer text. */
9495 if (EQ (mini_window
, selected_window
))
9496 CHARPOS (this_line_start_pos
) = 0;
9498 return window_height_changed_p
;
9503 /***********************************************************************
9504 Mode Lines and Frame Titles
9505 ***********************************************************************/
9507 /* A buffer for constructing non-propertized mode-line strings and
9508 frame titles in it; allocated from the heap in init_xdisp and
9509 resized as needed in store_mode_line_noprop_char. */
9511 static char *mode_line_noprop_buf
;
9513 /* The buffer's end, and a current output position in it. */
9515 static char *mode_line_noprop_buf_end
;
9516 static char *mode_line_noprop_ptr
;
9518 #define MODE_LINE_NOPROP_LEN(start) \
9519 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
9522 MODE_LINE_DISPLAY
= 0,
9528 /* Alist that caches the results of :propertize.
9529 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
9530 static Lisp_Object mode_line_proptrans_alist
;
9532 /* List of strings making up the mode-line. */
9533 static Lisp_Object mode_line_string_list
;
9535 /* Base face property when building propertized mode line string. */
9536 static Lisp_Object mode_line_string_face
;
9537 static Lisp_Object mode_line_string_face_prop
;
9540 /* Unwind data for mode line strings */
9542 static Lisp_Object Vmode_line_unwind_vector
;
9545 format_mode_line_unwind_data (struct buffer
*obuf
,
9549 Lisp_Object vector
, tmp
;
9551 /* Reduce consing by keeping one vector in
9552 Vwith_echo_area_save_vector. */
9553 vector
= Vmode_line_unwind_vector
;
9554 Vmode_line_unwind_vector
= Qnil
;
9557 vector
= Fmake_vector (make_number (8), Qnil
);
9559 ASET (vector
, 0, make_number (mode_line_target
));
9560 ASET (vector
, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
9561 ASET (vector
, 2, mode_line_string_list
);
9562 ASET (vector
, 3, save_proptrans
? mode_line_proptrans_alist
: Qt
);
9563 ASET (vector
, 4, mode_line_string_face
);
9564 ASET (vector
, 5, mode_line_string_face_prop
);
9567 XSETBUFFER (tmp
, obuf
);
9570 ASET (vector
, 6, tmp
);
9571 ASET (vector
, 7, owin
);
9577 unwind_format_mode_line (Lisp_Object vector
)
9579 mode_line_target
= XINT (AREF (vector
, 0));
9580 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
9581 mode_line_string_list
= AREF (vector
, 2);
9582 if (! EQ (AREF (vector
, 3), Qt
))
9583 mode_line_proptrans_alist
= AREF (vector
, 3);
9584 mode_line_string_face
= AREF (vector
, 4);
9585 mode_line_string_face_prop
= AREF (vector
, 5);
9587 if (!NILP (AREF (vector
, 7)))
9588 /* Select window before buffer, since it may change the buffer. */
9589 Fselect_window (AREF (vector
, 7), Qt
);
9591 if (!NILP (AREF (vector
, 6)))
9593 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
9594 ASET (vector
, 6, Qnil
);
9597 Vmode_line_unwind_vector
= vector
;
9602 /* Store a single character C for the frame title in mode_line_noprop_buf.
9603 Re-allocate mode_line_noprop_buf if necessary. */
9606 store_mode_line_noprop_char (char c
)
9608 /* If output position has reached the end of the allocated buffer,
9609 double the buffer's size. */
9610 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
9612 int len
= MODE_LINE_NOPROP_LEN (0);
9613 int new_size
= 2 * len
* sizeof *mode_line_noprop_buf
;
9614 mode_line_noprop_buf
= (char *) xrealloc (mode_line_noprop_buf
, new_size
);
9615 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ new_size
;
9616 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
9619 *mode_line_noprop_ptr
++ = c
;
9623 /* Store part of a frame title in mode_line_noprop_buf, beginning at
9624 mode_line_noprop_ptr. STRING is the string to store. Do not copy
9625 characters that yield more columns than PRECISION; PRECISION <= 0
9626 means copy the whole string. Pad with spaces until FIELD_WIDTH
9627 number of characters have been copied; FIELD_WIDTH <= 0 means don't
9628 pad. Called from display_mode_element when it is used to build a
9632 store_mode_line_noprop (const char *string
, int field_width
, int precision
)
9634 const unsigned char *str
= (const unsigned char *) string
;
9636 EMACS_INT dummy
, nbytes
;
9638 /* Copy at most PRECISION chars from STR. */
9639 nbytes
= strlen (string
);
9640 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
9642 store_mode_line_noprop_char (*str
++);
9644 /* Fill up with spaces until FIELD_WIDTH reached. */
9645 while (field_width
> 0
9648 store_mode_line_noprop_char (' ');
9655 /***********************************************************************
9657 ***********************************************************************/
9659 #ifdef HAVE_WINDOW_SYSTEM
9661 /* Set the title of FRAME, if it has changed. The title format is
9662 Vicon_title_format if FRAME is iconified, otherwise it is
9663 frame_title_format. */
9666 x_consider_frame_title (Lisp_Object frame
)
9668 struct frame
*f
= XFRAME (frame
);
9670 if (FRAME_WINDOW_P (f
)
9671 || FRAME_MINIBUF_ONLY_P (f
)
9672 || f
->explicit_name
)
9674 /* Do we have more than one visible frame on this X display? */
9681 int count
= SPECPDL_INDEX ();
9683 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
9685 Lisp_Object other_frame
= XCAR (tail
);
9686 struct frame
*tf
= XFRAME (other_frame
);
9689 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
9690 && !FRAME_MINIBUF_ONLY_P (tf
)
9691 && !EQ (other_frame
, tip_frame
)
9692 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
9696 /* Set global variable indicating that multiple frames exist. */
9697 multiple_frames
= CONSP (tail
);
9699 /* Switch to the buffer of selected window of the frame. Set up
9700 mode_line_target so that display_mode_element will output into
9701 mode_line_noprop_buf; then display the title. */
9702 record_unwind_protect (unwind_format_mode_line
,
9703 format_mode_line_unwind_data
9704 (current_buffer
, selected_window
, 0));
9706 Fselect_window (f
->selected_window
, Qt
);
9707 set_buffer_internal_1 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
9708 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
9710 mode_line_target
= MODE_LINE_TITLE
;
9711 title_start
= MODE_LINE_NOPROP_LEN (0);
9712 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
9713 NULL
, DEFAULT_FACE_ID
);
9714 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
9715 len
= MODE_LINE_NOPROP_LEN (title_start
);
9716 title
= mode_line_noprop_buf
+ title_start
;
9717 unbind_to (count
, Qnil
);
9719 /* Set the title only if it's changed. This avoids consing in
9720 the common case where it hasn't. (If it turns out that we've
9721 already wasted too much time by walking through the list with
9722 display_mode_element, then we might need to optimize at a
9723 higher level than this.) */
9724 if (! STRINGP (f
->name
)
9725 || SBYTES (f
->name
) != len
9726 || memcmp (title
, SDATA (f
->name
), len
) != 0)
9727 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
9731 #endif /* not HAVE_WINDOW_SYSTEM */
9736 /***********************************************************************
9738 ***********************************************************************/
9741 /* Prepare for redisplay by updating menu-bar item lists when
9742 appropriate. This can call eval. */
9745 prepare_menu_bars (void)
9748 struct gcpro gcpro1
, gcpro2
;
9750 Lisp_Object tooltip_frame
;
9752 #ifdef HAVE_WINDOW_SYSTEM
9753 tooltip_frame
= tip_frame
;
9755 tooltip_frame
= Qnil
;
9758 /* Update all frame titles based on their buffer names, etc. We do
9759 this before the menu bars so that the buffer-menu will show the
9760 up-to-date frame titles. */
9761 #ifdef HAVE_WINDOW_SYSTEM
9762 if (windows_or_buffers_changed
|| update_mode_lines
)
9764 Lisp_Object tail
, frame
;
9766 FOR_EACH_FRAME (tail
, frame
)
9769 if (!EQ (frame
, tooltip_frame
)
9770 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
9771 x_consider_frame_title (frame
);
9774 #endif /* HAVE_WINDOW_SYSTEM */
9776 /* Update the menu bar item lists, if appropriate. This has to be
9777 done before any actual redisplay or generation of display lines. */
9778 all_windows
= (update_mode_lines
9779 || buffer_shared
> 1
9780 || windows_or_buffers_changed
);
9783 Lisp_Object tail
, frame
;
9784 int count
= SPECPDL_INDEX ();
9785 /* 1 means that update_menu_bar has run its hooks
9786 so any further calls to update_menu_bar shouldn't do so again. */
9787 int menu_bar_hooks_run
= 0;
9789 record_unwind_save_match_data ();
9791 FOR_EACH_FRAME (tail
, frame
)
9795 /* Ignore tooltip frame. */
9796 if (EQ (frame
, tooltip_frame
))
9799 /* If a window on this frame changed size, report that to
9800 the user and clear the size-change flag. */
9801 if (FRAME_WINDOW_SIZES_CHANGED (f
))
9803 Lisp_Object functions
;
9805 /* Clear flag first in case we get an error below. */
9806 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
9807 functions
= Vwindow_size_change_functions
;
9808 GCPRO2 (tail
, functions
);
9810 while (CONSP (functions
))
9812 if (!EQ (XCAR (functions
), Qt
))
9813 call1 (XCAR (functions
), frame
);
9814 functions
= XCDR (functions
);
9820 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
9821 #ifdef HAVE_WINDOW_SYSTEM
9822 update_tool_bar (f
, 0);
9825 if (windows_or_buffers_changed
9827 ns_set_doc_edited (f
, Fbuffer_modified_p
9828 (XWINDOW (f
->selected_window
)->buffer
));
9833 unbind_to (count
, Qnil
);
9837 struct frame
*sf
= SELECTED_FRAME ();
9838 update_menu_bar (sf
, 1, 0);
9839 #ifdef HAVE_WINDOW_SYSTEM
9840 update_tool_bar (sf
, 1);
9846 /* Update the menu bar item list for frame F. This has to be done
9847 before we start to fill in any display lines, because it can call
9850 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
9852 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
9853 already ran the menu bar hooks for this redisplay, so there
9854 is no need to run them again. The return value is the
9855 updated value of this flag, to pass to the next call. */
9858 update_menu_bar (struct frame
*f
, int save_match_data
, int hooks_run
)
9861 register struct window
*w
;
9863 /* If called recursively during a menu update, do nothing. This can
9864 happen when, for instance, an activate-menubar-hook causes a
9866 if (inhibit_menubar_update
)
9869 window
= FRAME_SELECTED_WINDOW (f
);
9870 w
= XWINDOW (window
);
9872 if (FRAME_WINDOW_P (f
)
9874 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
9875 || defined (HAVE_NS) || defined (USE_GTK)
9876 FRAME_EXTERNAL_MENU_BAR (f
)
9878 FRAME_MENU_BAR_LINES (f
) > 0
9880 : FRAME_MENU_BAR_LINES (f
) > 0)
9882 /* If the user has switched buffers or windows, we need to
9883 recompute to reflect the new bindings. But we'll
9884 recompute when update_mode_lines is set too; that means
9885 that people can use force-mode-line-update to request
9886 that the menu bar be recomputed. The adverse effect on
9887 the rest of the redisplay algorithm is about the same as
9888 windows_or_buffers_changed anyway. */
9889 if (windows_or_buffers_changed
9890 /* This used to test w->update_mode_line, but we believe
9891 there is no need to recompute the menu in that case. */
9892 || update_mode_lines
9893 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
9894 < BUF_MODIFF (XBUFFER (w
->buffer
)))
9895 != !NILP (w
->last_had_star
))
9896 || ((!NILP (Vtransient_mark_mode
)
9897 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
9898 != !NILP (w
->region_showing
)))
9900 struct buffer
*prev
= current_buffer
;
9901 int count
= SPECPDL_INDEX ();
9903 specbind (Qinhibit_menubar_update
, Qt
);
9905 set_buffer_internal_1 (XBUFFER (w
->buffer
));
9906 if (save_match_data
)
9907 record_unwind_save_match_data ();
9908 if (NILP (Voverriding_local_map_menu_flag
))
9910 specbind (Qoverriding_terminal_local_map
, Qnil
);
9911 specbind (Qoverriding_local_map
, Qnil
);
9916 /* Run the Lucid hook. */
9917 safe_run_hooks (Qactivate_menubar_hook
);
9919 /* If it has changed current-menubar from previous value,
9920 really recompute the menu-bar from the value. */
9921 if (! NILP (Vlucid_menu_bar_dirty_flag
))
9922 call0 (Qrecompute_lucid_menubar
);
9924 safe_run_hooks (Qmenu_bar_update_hook
);
9929 XSETFRAME (Vmenu_updating_frame
, f
);
9930 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
9932 /* Redisplay the menu bar in case we changed it. */
9933 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
9934 || defined (HAVE_NS) || defined (USE_GTK)
9935 if (FRAME_WINDOW_P (f
))
9937 #if defined (HAVE_NS)
9938 /* All frames on Mac OS share the same menubar. So only
9939 the selected frame should be allowed to set it. */
9940 if (f
== SELECTED_FRAME ())
9942 set_frame_menubar (f
, 0, 0);
9945 /* On a terminal screen, the menu bar is an ordinary screen
9946 line, and this makes it get updated. */
9947 w
->update_mode_line
= Qt
;
9948 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
9949 /* In the non-toolkit version, the menu bar is an ordinary screen
9950 line, and this makes it get updated. */
9951 w
->update_mode_line
= Qt
;
9952 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
9954 unbind_to (count
, Qnil
);
9955 set_buffer_internal_1 (prev
);
9964 /***********************************************************************
9966 ***********************************************************************/
9968 #ifdef HAVE_WINDOW_SYSTEM
9971 Nominal cursor position -- where to draw output.
9972 HPOS and VPOS are window relative glyph matrix coordinates.
9973 X and Y are window relative pixel coordinates. */
9975 struct cursor_pos output_cursor
;
9979 Set the global variable output_cursor to CURSOR. All cursor
9980 positions are relative to updated_window. */
9983 set_output_cursor (struct cursor_pos
*cursor
)
9985 output_cursor
.hpos
= cursor
->hpos
;
9986 output_cursor
.vpos
= cursor
->vpos
;
9987 output_cursor
.x
= cursor
->x
;
9988 output_cursor
.y
= cursor
->y
;
9993 Set a nominal cursor position.
9995 HPOS and VPOS are column/row positions in a window glyph matrix. X
9996 and Y are window text area relative pixel positions.
9998 If this is done during an update, updated_window will contain the
9999 window that is being updated and the position is the future output
10000 cursor position for that window. If updated_window is null, use
10001 selected_window and display the cursor at the given position. */
10004 x_cursor_to (int vpos
, int hpos
, int y
, int x
)
10008 /* If updated_window is not set, work on selected_window. */
10009 if (updated_window
)
10010 w
= updated_window
;
10012 w
= XWINDOW (selected_window
);
10014 /* Set the output cursor. */
10015 output_cursor
.hpos
= hpos
;
10016 output_cursor
.vpos
= vpos
;
10017 output_cursor
.x
= x
;
10018 output_cursor
.y
= y
;
10020 /* If not called as part of an update, really display the cursor.
10021 This will also set the cursor position of W. */
10022 if (updated_window
== NULL
)
10025 display_and_set_cursor (w
, 1, hpos
, vpos
, x
, y
);
10026 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
10027 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
10032 #endif /* HAVE_WINDOW_SYSTEM */
10035 /***********************************************************************
10037 ***********************************************************************/
10039 #ifdef HAVE_WINDOW_SYSTEM
10041 /* Where the mouse was last time we reported a mouse event. */
10043 FRAME_PTR last_mouse_frame
;
10045 /* Tool-bar item index of the item on which a mouse button was pressed
10048 int last_tool_bar_item
;
10052 update_tool_bar_unwind (Lisp_Object frame
)
10054 selected_frame
= frame
;
10058 /* Update the tool-bar item list for frame F. This has to be done
10059 before we start to fill in any display lines. Called from
10060 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
10061 and restore it here. */
10064 update_tool_bar (struct frame
*f
, int save_match_data
)
10066 #if defined (USE_GTK) || defined (HAVE_NS)
10067 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
10069 int do_update
= WINDOWP (f
->tool_bar_window
)
10070 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0;
10075 Lisp_Object window
;
10078 window
= FRAME_SELECTED_WINDOW (f
);
10079 w
= XWINDOW (window
);
10081 /* If the user has switched buffers or windows, we need to
10082 recompute to reflect the new bindings. But we'll
10083 recompute when update_mode_lines is set too; that means
10084 that people can use force-mode-line-update to request
10085 that the menu bar be recomputed. The adverse effect on
10086 the rest of the redisplay algorithm is about the same as
10087 windows_or_buffers_changed anyway. */
10088 if (windows_or_buffers_changed
10089 || !NILP (w
->update_mode_line
)
10090 || update_mode_lines
10091 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
10092 < BUF_MODIFF (XBUFFER (w
->buffer
)))
10093 != !NILP (w
->last_had_star
))
10094 || ((!NILP (Vtransient_mark_mode
)
10095 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
10096 != !NILP (w
->region_showing
)))
10098 struct buffer
*prev
= current_buffer
;
10099 int count
= SPECPDL_INDEX ();
10100 Lisp_Object frame
, new_tool_bar
;
10101 int new_n_tool_bar
;
10102 struct gcpro gcpro1
;
10104 /* Set current_buffer to the buffer of the selected
10105 window of the frame, so that we get the right local
10107 set_buffer_internal_1 (XBUFFER (w
->buffer
));
10109 /* Save match data, if we must. */
10110 if (save_match_data
)
10111 record_unwind_save_match_data ();
10113 /* Make sure that we don't accidentally use bogus keymaps. */
10114 if (NILP (Voverriding_local_map_menu_flag
))
10116 specbind (Qoverriding_terminal_local_map
, Qnil
);
10117 specbind (Qoverriding_local_map
, Qnil
);
10120 GCPRO1 (new_tool_bar
);
10122 /* We must temporarily set the selected frame to this frame
10123 before calling tool_bar_items, because the calculation of
10124 the tool-bar keymap uses the selected frame (see
10125 `tool-bar-make-keymap' in tool-bar.el). */
10126 record_unwind_protect (update_tool_bar_unwind
, selected_frame
);
10127 XSETFRAME (frame
, f
);
10128 selected_frame
= frame
;
10130 /* Build desired tool-bar items from keymaps. */
10131 new_tool_bar
= tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
10134 /* Redisplay the tool-bar if we changed it. */
10135 if (new_n_tool_bar
!= f
->n_tool_bar_items
10136 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
10138 /* Redisplay that happens asynchronously due to an expose event
10139 may access f->tool_bar_items. Make sure we update both
10140 variables within BLOCK_INPUT so no such event interrupts. */
10142 f
->tool_bar_items
= new_tool_bar
;
10143 f
->n_tool_bar_items
= new_n_tool_bar
;
10144 w
->update_mode_line
= Qt
;
10150 unbind_to (count
, Qnil
);
10151 set_buffer_internal_1 (prev
);
10157 /* Set F->desired_tool_bar_string to a Lisp string representing frame
10158 F's desired tool-bar contents. F->tool_bar_items must have
10159 been set up previously by calling prepare_menu_bars. */
10162 build_desired_tool_bar_string (struct frame
*f
)
10164 int i
, size
, size_needed
;
10165 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10166 Lisp_Object image
, plist
, props
;
10168 image
= plist
= props
= Qnil
;
10169 GCPRO3 (image
, plist
, props
);
10171 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
10172 Otherwise, make a new string. */
10174 /* The size of the string we might be able to reuse. */
10175 size
= (STRINGP (f
->desired_tool_bar_string
)
10176 ? SCHARS (f
->desired_tool_bar_string
)
10179 /* We need one space in the string for each image. */
10180 size_needed
= f
->n_tool_bar_items
;
10182 /* Reuse f->desired_tool_bar_string, if possible. */
10183 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
10184 f
->desired_tool_bar_string
= Fmake_string (make_number (size_needed
),
10185 make_number (' '));
10188 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
10189 Fremove_text_properties (make_number (0), make_number (size
),
10190 props
, f
->desired_tool_bar_string
);
10193 /* Put a `display' property on the string for the images to display,
10194 put a `menu_item' property on tool-bar items with a value that
10195 is the index of the item in F's tool-bar item vector. */
10196 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
10198 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
10200 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
10201 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
10202 int hmargin
, vmargin
, relief
, idx
, end
;
10204 /* If image is a vector, choose the image according to the
10206 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
10207 if (VECTORP (image
))
10211 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
10212 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
10215 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
10216 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
10218 xassert (ASIZE (image
) >= idx
);
10219 image
= AREF (image
, idx
);
10224 /* Ignore invalid image specifications. */
10225 if (!valid_image_p (image
))
10228 /* Display the tool-bar button pressed, or depressed. */
10229 plist
= Fcopy_sequence (XCDR (image
));
10231 /* Compute margin and relief to draw. */
10232 relief
= (tool_bar_button_relief
>= 0
10233 ? tool_bar_button_relief
10234 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
10235 hmargin
= vmargin
= relief
;
10237 if (INTEGERP (Vtool_bar_button_margin
)
10238 && XINT (Vtool_bar_button_margin
) > 0)
10240 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
10241 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
10243 else if (CONSP (Vtool_bar_button_margin
))
10245 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
10246 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
10247 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
10249 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
10250 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
10251 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
10254 if (auto_raise_tool_bar_buttons_p
)
10256 /* Add a `:relief' property to the image spec if the item is
10260 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
10267 /* If image is selected, display it pressed, i.e. with a
10268 negative relief. If it's not selected, display it with a
10270 plist
= Fplist_put (plist
, QCrelief
,
10272 ? make_number (-relief
)
10273 : make_number (relief
)));
10278 /* Put a margin around the image. */
10279 if (hmargin
|| vmargin
)
10281 if (hmargin
== vmargin
)
10282 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
10284 plist
= Fplist_put (plist
, QCmargin
,
10285 Fcons (make_number (hmargin
),
10286 make_number (vmargin
)));
10289 /* If button is not enabled, and we don't have special images
10290 for the disabled state, make the image appear disabled by
10291 applying an appropriate algorithm to it. */
10292 if (!enabled_p
&& idx
< 0)
10293 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
10295 /* Put a `display' text property on the string for the image to
10296 display. Put a `menu-item' property on the string that gives
10297 the start of this item's properties in the tool-bar items
10299 image
= Fcons (Qimage
, plist
);
10300 props
= list4 (Qdisplay
, image
,
10301 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
10303 /* Let the last image hide all remaining spaces in the tool bar
10304 string. The string can be longer than needed when we reuse a
10305 previous string. */
10306 if (i
+ 1 == f
->n_tool_bar_items
)
10307 end
= SCHARS (f
->desired_tool_bar_string
);
10310 Fadd_text_properties (make_number (i
), make_number (end
),
10311 props
, f
->desired_tool_bar_string
);
10319 /* Display one line of the tool-bar of frame IT->f.
10321 HEIGHT specifies the desired height of the tool-bar line.
10322 If the actual height of the glyph row is less than HEIGHT, the
10323 row's height is increased to HEIGHT, and the icons are centered
10324 vertically in the new height.
10326 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
10327 count a final empty row in case the tool-bar width exactly matches
10332 display_tool_bar_line (struct it
*it
, int height
)
10334 struct glyph_row
*row
= it
->glyph_row
;
10335 int max_x
= it
->last_visible_x
;
10336 struct glyph
*last
;
10338 prepare_desired_row (row
);
10339 row
->y
= it
->current_y
;
10341 /* Note that this isn't made use of if the face hasn't a box,
10342 so there's no need to check the face here. */
10343 it
->start_of_box_run_p
= 1;
10345 while (it
->current_x
< max_x
)
10347 int x
, n_glyphs_before
, i
, nglyphs
;
10348 struct it it_before
;
10350 /* Get the next display element. */
10351 if (!get_next_display_element (it
))
10353 /* Don't count empty row if we are counting needed tool-bar lines. */
10354 if (height
< 0 && !it
->hpos
)
10359 /* Produce glyphs. */
10360 n_glyphs_before
= row
->used
[TEXT_AREA
];
10363 PRODUCE_GLYPHS (it
);
10365 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
10367 x
= it_before
.current_x
;
10368 while (i
< nglyphs
)
10370 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
10372 if (x
+ glyph
->pixel_width
> max_x
)
10374 /* Glyph doesn't fit on line. Backtrack. */
10375 row
->used
[TEXT_AREA
] = n_glyphs_before
;
10377 /* If this is the only glyph on this line, it will never fit on the
10378 tool-bar, so skip it. But ensure there is at least one glyph,
10379 so we don't accidentally disable the tool-bar. */
10380 if (n_glyphs_before
== 0
10381 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
10387 x
+= glyph
->pixel_width
;
10391 /* Stop at line ends. */
10392 if (ITERATOR_AT_END_OF_LINE_P (it
))
10395 set_iterator_to_next (it
, 1);
10400 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
10402 /* Use default face for the border below the tool bar.
10404 FIXME: When auto-resize-tool-bars is grow-only, there is
10405 no additional border below the possibly empty tool-bar lines.
10406 So to make the extra empty lines look "normal", we have to
10407 use the tool-bar face for the border too. */
10408 if (!row
->displays_text_p
&& !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
10409 it
->face_id
= DEFAULT_FACE_ID
;
10411 extend_face_to_end_of_line (it
);
10412 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
10413 last
->right_box_line_p
= 1;
10414 if (last
== row
->glyphs
[TEXT_AREA
])
10415 last
->left_box_line_p
= 1;
10417 /* Make line the desired height and center it vertically. */
10418 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
10420 /* Don't add more than one line height. */
10421 height
%= FRAME_LINE_HEIGHT (it
->f
);
10422 it
->max_ascent
+= height
/ 2;
10423 it
->max_descent
+= (height
+ 1) / 2;
10426 compute_line_metrics (it
);
10428 /* If line is empty, make it occupy the rest of the tool-bar. */
10429 if (!row
->displays_text_p
)
10431 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
10432 row
->visible_height
= row
->height
;
10433 row
->ascent
= row
->phys_ascent
= 0;
10434 row
->extra_line_spacing
= 0;
10437 row
->full_width_p
= 1;
10438 row
->continued_p
= 0;
10439 row
->truncated_on_left_p
= 0;
10440 row
->truncated_on_right_p
= 0;
10442 it
->current_x
= it
->hpos
= 0;
10443 it
->current_y
+= row
->height
;
10449 /* Max tool-bar height. */
10451 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
10452 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
10454 /* Value is the number of screen lines needed to make all tool-bar
10455 items of frame F visible. The number of actual rows needed is
10456 returned in *N_ROWS if non-NULL. */
10459 tool_bar_lines_needed (struct frame
*f
, int *n_rows
)
10461 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10463 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
10464 the desired matrix, so use (unused) mode-line row as temporary row to
10465 avoid destroying the first tool-bar row. */
10466 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
10468 /* Initialize an iterator for iteration over
10469 F->desired_tool_bar_string in the tool-bar window of frame F. */
10470 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
10471 it
.first_visible_x
= 0;
10472 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
10473 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
10475 while (!ITERATOR_AT_END_P (&it
))
10477 clear_glyph_row (temp_row
);
10478 it
.glyph_row
= temp_row
;
10479 display_tool_bar_line (&it
, -1);
10481 clear_glyph_row (temp_row
);
10483 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
10485 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
10487 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
10491 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
10493 doc
: /* Return the number of lines occupied by the tool bar of FRAME. */)
10494 (Lisp_Object frame
)
10501 frame
= selected_frame
;
10503 CHECK_FRAME (frame
);
10504 f
= XFRAME (frame
);
10506 if (WINDOWP (f
->tool_bar_window
)
10507 || (w
= XWINDOW (f
->tool_bar_window
),
10508 WINDOW_TOTAL_LINES (w
) > 0))
10510 update_tool_bar (f
, 1);
10511 if (f
->n_tool_bar_items
)
10513 build_desired_tool_bar_string (f
);
10514 nlines
= tool_bar_lines_needed (f
, NULL
);
10518 return make_number (nlines
);
10522 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
10523 height should be changed. */
10526 redisplay_tool_bar (struct frame
*f
)
10530 struct glyph_row
*row
;
10532 #if defined (USE_GTK) || defined (HAVE_NS)
10533 if (FRAME_EXTERNAL_TOOL_BAR (f
))
10534 update_frame_tool_bar (f
);
10538 /* If frame hasn't a tool-bar window or if it is zero-height, don't
10539 do anything. This means you must start with tool-bar-lines
10540 non-zero to get the auto-sizing effect. Or in other words, you
10541 can turn off tool-bars by specifying tool-bar-lines zero. */
10542 if (!WINDOWP (f
->tool_bar_window
)
10543 || (w
= XWINDOW (f
->tool_bar_window
),
10544 WINDOW_TOTAL_LINES (w
) == 0))
10547 /* Set up an iterator for the tool-bar window. */
10548 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
10549 it
.first_visible_x
= 0;
10550 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
10551 row
= it
.glyph_row
;
10553 /* Build a string that represents the contents of the tool-bar. */
10554 build_desired_tool_bar_string (f
);
10555 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
10557 if (f
->n_tool_bar_rows
== 0)
10561 if ((nlines
= tool_bar_lines_needed (f
, &f
->n_tool_bar_rows
),
10562 nlines
!= WINDOW_TOTAL_LINES (w
)))
10565 int old_height
= WINDOW_TOTAL_LINES (w
);
10567 XSETFRAME (frame
, f
);
10568 Fmodify_frame_parameters (frame
,
10569 Fcons (Fcons (Qtool_bar_lines
,
10570 make_number (nlines
)),
10572 if (WINDOW_TOTAL_LINES (w
) != old_height
)
10574 clear_glyph_matrix (w
->desired_matrix
);
10575 fonts_changed_p
= 1;
10581 /* Display as many lines as needed to display all tool-bar items. */
10583 if (f
->n_tool_bar_rows
> 0)
10585 int border
, rows
, height
, extra
;
10587 if (INTEGERP (Vtool_bar_border
))
10588 border
= XINT (Vtool_bar_border
);
10589 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
10590 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
10591 else if (EQ (Vtool_bar_border
, Qborder_width
))
10592 border
= f
->border_width
;
10598 rows
= f
->n_tool_bar_rows
;
10599 height
= max (1, (it
.last_visible_y
- border
) / rows
);
10600 extra
= it
.last_visible_y
- border
- height
* rows
;
10602 while (it
.current_y
< it
.last_visible_y
)
10605 if (extra
> 0 && rows
-- > 0)
10607 h
= (extra
+ rows
- 1) / rows
;
10610 display_tool_bar_line (&it
, height
+ h
);
10615 while (it
.current_y
< it
.last_visible_y
)
10616 display_tool_bar_line (&it
, 0);
10619 /* It doesn't make much sense to try scrolling in the tool-bar
10620 window, so don't do it. */
10621 w
->desired_matrix
->no_scrolling_p
= 1;
10622 w
->must_be_updated_p
= 1;
10624 if (!NILP (Vauto_resize_tool_bars
))
10626 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
10627 int change_height_p
= 0;
10629 /* If we couldn't display everything, change the tool-bar's
10630 height if there is room for more. */
10631 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
10632 && it
.current_y
< max_tool_bar_height
)
10633 change_height_p
= 1;
10635 row
= it
.glyph_row
- 1;
10637 /* If there are blank lines at the end, except for a partially
10638 visible blank line at the end that is smaller than
10639 FRAME_LINE_HEIGHT, change the tool-bar's height. */
10640 if (!row
->displays_text_p
10641 && row
->height
>= FRAME_LINE_HEIGHT (f
))
10642 change_height_p
= 1;
10644 /* If row displays tool-bar items, but is partially visible,
10645 change the tool-bar's height. */
10646 if (row
->displays_text_p
10647 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
10648 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
10649 change_height_p
= 1;
10651 /* Resize windows as needed by changing the `tool-bar-lines'
10652 frame parameter. */
10653 if (change_height_p
)
10656 int old_height
= WINDOW_TOTAL_LINES (w
);
10658 int nlines
= tool_bar_lines_needed (f
, &nrows
);
10660 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
10661 && !f
->minimize_tool_bar_window_p
)
10662 ? (nlines
> old_height
)
10663 : (nlines
!= old_height
));
10664 f
->minimize_tool_bar_window_p
= 0;
10666 if (change_height_p
)
10668 XSETFRAME (frame
, f
);
10669 Fmodify_frame_parameters (frame
,
10670 Fcons (Fcons (Qtool_bar_lines
,
10671 make_number (nlines
)),
10673 if (WINDOW_TOTAL_LINES (w
) != old_height
)
10675 clear_glyph_matrix (w
->desired_matrix
);
10676 f
->n_tool_bar_rows
= nrows
;
10677 fonts_changed_p
= 1;
10684 f
->minimize_tool_bar_window_p
= 0;
10689 /* Get information about the tool-bar item which is displayed in GLYPH
10690 on frame F. Return in *PROP_IDX the index where tool-bar item
10691 properties start in F->tool_bar_items. Value is zero if
10692 GLYPH doesn't display a tool-bar item. */
10695 tool_bar_item_info (struct frame
*f
, struct glyph
*glyph
, int *prop_idx
)
10701 /* This function can be called asynchronously, which means we must
10702 exclude any possibility that Fget_text_property signals an
10704 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
10705 charpos
= max (0, charpos
);
10707 /* Get the text property `menu-item' at pos. The value of that
10708 property is the start index of this item's properties in
10709 F->tool_bar_items. */
10710 prop
= Fget_text_property (make_number (charpos
),
10711 Qmenu_item
, f
->current_tool_bar_string
);
10712 if (INTEGERP (prop
))
10714 *prop_idx
= XINT (prop
);
10724 /* Get information about the tool-bar item at position X/Y on frame F.
10725 Return in *GLYPH a pointer to the glyph of the tool-bar item in
10726 the current matrix of the tool-bar window of F, or NULL if not
10727 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
10728 item in F->tool_bar_items. Value is
10730 -1 if X/Y is not on a tool-bar item
10731 0 if X/Y is on the same item that was highlighted before.
10735 get_tool_bar_item (struct frame
*f
, int x
, int y
, struct glyph
**glyph
,
10736 int *hpos
, int *vpos
, int *prop_idx
)
10738 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
10739 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10742 /* Find the glyph under X/Y. */
10743 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
10744 if (*glyph
== NULL
)
10747 /* Get the start of this tool-bar item's properties in
10748 f->tool_bar_items. */
10749 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
10752 /* Is mouse on the highlighted item? */
10753 if (EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)
10754 && *vpos
>= hlinfo
->mouse_face_beg_row
10755 && *vpos
<= hlinfo
->mouse_face_end_row
10756 && (*vpos
> hlinfo
->mouse_face_beg_row
10757 || *hpos
>= hlinfo
->mouse_face_beg_col
)
10758 && (*vpos
< hlinfo
->mouse_face_end_row
10759 || *hpos
< hlinfo
->mouse_face_end_col
10760 || hlinfo
->mouse_face_past_end
))
10768 Handle mouse button event on the tool-bar of frame F, at
10769 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
10770 0 for button release. MODIFIERS is event modifiers for button
10774 handle_tool_bar_click (struct frame
*f
, int x
, int y
, int down_p
,
10775 unsigned int modifiers
)
10777 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
10778 struct window
*w
= XWINDOW (f
->tool_bar_window
);
10779 int hpos
, vpos
, prop_idx
;
10780 struct glyph
*glyph
;
10781 Lisp_Object enabled_p
;
10783 /* If not on the highlighted tool-bar item, return. */
10784 frame_to_window_pixel_xy (w
, &x
, &y
);
10785 if (get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
10788 /* If item is disabled, do nothing. */
10789 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
10790 if (NILP (enabled_p
))
10795 /* Show item in pressed state. */
10796 show_mouse_face (hlinfo
, DRAW_IMAGE_SUNKEN
);
10797 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
10798 last_tool_bar_item
= prop_idx
;
10802 Lisp_Object key
, frame
;
10803 struct input_event event
;
10804 EVENT_INIT (event
);
10806 /* Show item in released state. */
10807 show_mouse_face (hlinfo
, DRAW_IMAGE_RAISED
);
10808 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
10810 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
10812 XSETFRAME (frame
, f
);
10813 event
.kind
= TOOL_BAR_EVENT
;
10814 event
.frame_or_window
= frame
;
10816 kbd_buffer_store_event (&event
);
10818 event
.kind
= TOOL_BAR_EVENT
;
10819 event
.frame_or_window
= frame
;
10821 event
.modifiers
= modifiers
;
10822 kbd_buffer_store_event (&event
);
10823 last_tool_bar_item
= -1;
10828 /* Possibly highlight a tool-bar item on frame F when mouse moves to
10829 tool-bar window-relative coordinates X/Y. Called from
10830 note_mouse_highlight. */
10833 note_tool_bar_highlight (struct frame
*f
, int x
, int y
)
10835 Lisp_Object window
= f
->tool_bar_window
;
10836 struct window
*w
= XWINDOW (window
);
10837 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10838 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
10840 struct glyph
*glyph
;
10841 struct glyph_row
*row
;
10843 Lisp_Object enabled_p
;
10845 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
10846 int mouse_down_p
, rc
;
10848 /* Function note_mouse_highlight is called with negative X/Y
10849 values when mouse moves outside of the frame. */
10850 if (x
<= 0 || y
<= 0)
10852 clear_mouse_face (hlinfo
);
10856 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
10859 /* Not on tool-bar item. */
10860 clear_mouse_face (hlinfo
);
10864 /* On same tool-bar item as before. */
10865 goto set_help_echo
;
10867 clear_mouse_face (hlinfo
);
10869 /* Mouse is down, but on different tool-bar item? */
10870 mouse_down_p
= (dpyinfo
->grabbed
10871 && f
== last_mouse_frame
10872 && FRAME_LIVE_P (f
));
10874 && last_tool_bar_item
!= prop_idx
)
10877 hlinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
10878 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
10880 /* If tool-bar item is not enabled, don't highlight it. */
10881 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
10882 if (!NILP (enabled_p
))
10884 /* Compute the x-position of the glyph. In front and past the
10885 image is a space. We include this in the highlighted area. */
10886 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
10887 for (i
= x
= 0; i
< hpos
; ++i
)
10888 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
10890 /* Record this as the current active region. */
10891 hlinfo
->mouse_face_beg_col
= hpos
;
10892 hlinfo
->mouse_face_beg_row
= vpos
;
10893 hlinfo
->mouse_face_beg_x
= x
;
10894 hlinfo
->mouse_face_beg_y
= row
->y
;
10895 hlinfo
->mouse_face_past_end
= 0;
10897 hlinfo
->mouse_face_end_col
= hpos
+ 1;
10898 hlinfo
->mouse_face_end_row
= vpos
;
10899 hlinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
10900 hlinfo
->mouse_face_end_y
= row
->y
;
10901 hlinfo
->mouse_face_window
= window
;
10902 hlinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
10904 /* Display it as active. */
10905 show_mouse_face (hlinfo
, draw
);
10906 hlinfo
->mouse_face_image_state
= draw
;
10911 /* Set help_echo_string to a help string to display for this tool-bar item.
10912 XTread_socket does the rest. */
10913 help_echo_object
= help_echo_window
= Qnil
;
10914 help_echo_pos
= -1;
10915 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
10916 if (NILP (help_echo_string
))
10917 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
10920 #endif /* HAVE_WINDOW_SYSTEM */
10924 /************************************************************************
10925 Horizontal scrolling
10926 ************************************************************************/
10928 static int hscroll_window_tree (Lisp_Object
);
10929 static int hscroll_windows (Lisp_Object
);
10931 /* For all leaf windows in the window tree rooted at WINDOW, set their
10932 hscroll value so that PT is (i) visible in the window, and (ii) so
10933 that it is not within a certain margin at the window's left and
10934 right border. Value is non-zero if any window's hscroll has been
10938 hscroll_window_tree (Lisp_Object window
)
10940 int hscrolled_p
= 0;
10941 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
10942 int hscroll_step_abs
= 0;
10943 double hscroll_step_rel
= 0;
10945 if (hscroll_relative_p
)
10947 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
10948 if (hscroll_step_rel
< 0)
10950 hscroll_relative_p
= 0;
10951 hscroll_step_abs
= 0;
10954 else if (INTEGERP (Vhscroll_step
))
10956 hscroll_step_abs
= XINT (Vhscroll_step
);
10957 if (hscroll_step_abs
< 0)
10958 hscroll_step_abs
= 0;
10961 hscroll_step_abs
= 0;
10963 while (WINDOWP (window
))
10965 struct window
*w
= XWINDOW (window
);
10967 if (WINDOWP (w
->hchild
))
10968 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
10969 else if (WINDOWP (w
->vchild
))
10970 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
10971 else if (w
->cursor
.vpos
>= 0)
10974 int text_area_width
;
10975 struct glyph_row
*current_cursor_row
10976 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
10977 struct glyph_row
*desired_cursor_row
10978 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
10979 struct glyph_row
*cursor_row
10980 = (desired_cursor_row
->enabled_p
10981 ? desired_cursor_row
10982 : current_cursor_row
);
10984 text_area_width
= window_box_width (w
, TEXT_AREA
);
10986 /* Scroll when cursor is inside this scroll margin. */
10987 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
10989 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode
, w
->buffer
))
10990 && ((XFASTINT (w
->hscroll
)
10991 && w
->cursor
.x
<= h_margin
)
10992 || (cursor_row
->enabled_p
10993 && cursor_row
->truncated_on_right_p
10994 && (w
->cursor
.x
>= text_area_width
- h_margin
))))
10998 struct buffer
*saved_current_buffer
;
11002 /* Find point in a display of infinite width. */
11003 saved_current_buffer
= current_buffer
;
11004 current_buffer
= XBUFFER (w
->buffer
);
11006 if (w
== XWINDOW (selected_window
))
11010 pt
= marker_position (w
->pointm
);
11011 pt
= max (BEGV
, pt
);
11015 /* Move iterator to pt starting at cursor_row->start in
11016 a line with infinite width. */
11017 init_to_row_start (&it
, w
, cursor_row
);
11018 it
.last_visible_x
= INFINITY
;
11019 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
11020 current_buffer
= saved_current_buffer
;
11022 /* Position cursor in window. */
11023 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
11024 hscroll
= max (0, (it
.current_x
11025 - (ITERATOR_AT_END_OF_LINE_P (&it
)
11026 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
11027 : (text_area_width
/ 2))))
11028 / FRAME_COLUMN_WIDTH (it
.f
);
11029 else if (w
->cursor
.x
>= text_area_width
- h_margin
)
11031 if (hscroll_relative_p
)
11032 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
11035 wanted_x
= text_area_width
11036 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
11039 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
11043 if (hscroll_relative_p
)
11044 wanted_x
= text_area_width
* hscroll_step_rel
11047 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
11050 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
11052 hscroll
= max (hscroll
, XFASTINT (w
->min_hscroll
));
11054 /* Don't call Fset_window_hscroll if value hasn't
11055 changed because it will prevent redisplay
11057 if (XFASTINT (w
->hscroll
) != hscroll
)
11059 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
11060 w
->hscroll
= make_number (hscroll
);
11069 /* Value is non-zero if hscroll of any leaf window has been changed. */
11070 return hscrolled_p
;
11074 /* Set hscroll so that cursor is visible and not inside horizontal
11075 scroll margins for all windows in the tree rooted at WINDOW. See
11076 also hscroll_window_tree above. Value is non-zero if any window's
11077 hscroll has been changed. If it has, desired matrices on the frame
11078 of WINDOW are cleared. */
11081 hscroll_windows (Lisp_Object window
)
11083 int hscrolled_p
= hscroll_window_tree (window
);
11085 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
11086 return hscrolled_p
;
11091 /************************************************************************
11093 ************************************************************************/
11095 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
11096 to a non-zero value. This is sometimes handy to have in a debugger
11101 /* First and last unchanged row for try_window_id. */
11103 int debug_first_unchanged_at_end_vpos
;
11104 int debug_last_unchanged_at_beg_vpos
;
11106 /* Delta vpos and y. */
11108 int debug_dvpos
, debug_dy
;
11110 /* Delta in characters and bytes for try_window_id. */
11112 EMACS_INT debug_delta
, debug_delta_bytes
;
11114 /* Values of window_end_pos and window_end_vpos at the end of
11117 EMACS_INT debug_end_vpos
;
11119 /* Append a string to W->desired_matrix->method. FMT is a printf
11120 format string. A1...A9 are a supplement for a variable-length
11121 argument list. If trace_redisplay_p is non-zero also printf the
11122 resulting string to stderr. */
11125 debug_method_add (w
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
11128 int a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
;
11131 char *method
= w
->desired_matrix
->method
;
11132 int len
= strlen (method
);
11133 int size
= sizeof w
->desired_matrix
->method
;
11134 int remaining
= size
- len
- 1;
11136 sprintf (buffer
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
11137 if (len
&& remaining
)
11140 --remaining
, ++len
;
11143 strncpy (method
+ len
, buffer
, remaining
);
11145 if (trace_redisplay_p
)
11146 fprintf (stderr
, "%p (%s): %s\n",
11148 ((BUFFERP (w
->buffer
)
11149 && STRINGP (BVAR (XBUFFER (w
->buffer
), name
)))
11150 ? SSDATA (BVAR (XBUFFER (w
->buffer
), name
))
11155 #endif /* GLYPH_DEBUG */
11158 /* Value is non-zero if all changes in window W, which displays
11159 current_buffer, are in the text between START and END. START is a
11160 buffer position, END is given as a distance from Z. Used in
11161 redisplay_internal for display optimization. */
11164 text_outside_line_unchanged_p (struct window
*w
,
11165 EMACS_INT start
, EMACS_INT end
)
11167 int unchanged_p
= 1;
11169 /* If text or overlays have changed, see where. */
11170 if (XFASTINT (w
->last_modified
) < MODIFF
11171 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
11173 /* Gap in the line? */
11174 if (GPT
< start
|| Z
- GPT
< end
)
11177 /* Changes start in front of the line, or end after it? */
11179 && (BEG_UNCHANGED
< start
- 1
11180 || END_UNCHANGED
< end
))
11183 /* If selective display, can't optimize if changes start at the
11184 beginning of the line. */
11186 && INTEGERP (BVAR (current_buffer
, selective_display
))
11187 && XINT (BVAR (current_buffer
, selective_display
)) > 0
11188 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
11191 /* If there are overlays at the start or end of the line, these
11192 may have overlay strings with newlines in them. A change at
11193 START, for instance, may actually concern the display of such
11194 overlay strings as well, and they are displayed on different
11195 lines. So, quickly rule out this case. (For the future, it
11196 might be desirable to implement something more telling than
11197 just BEG/END_UNCHANGED.) */
11200 if (BEG
+ BEG_UNCHANGED
== start
11201 && overlay_touches_p (start
))
11203 if (END_UNCHANGED
== end
11204 && overlay_touches_p (Z
- end
))
11208 /* Under bidi reordering, adding or deleting a character in the
11209 beginning of a paragraph, before the first strong directional
11210 character, can change the base direction of the paragraph (unless
11211 the buffer specifies a fixed paragraph direction), which will
11212 require to redisplay the whole paragraph. It might be worthwhile
11213 to find the paragraph limits and widen the range of redisplayed
11214 lines to that, but for now just give up this optimization. */
11215 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
11216 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
11220 return unchanged_p
;
11224 /* Do a frame update, taking possible shortcuts into account. This is
11225 the main external entry point for redisplay.
11227 If the last redisplay displayed an echo area message and that message
11228 is no longer requested, we clear the echo area or bring back the
11229 mini-buffer if that is in use. */
11234 redisplay_internal ();
11239 overlay_arrow_string_or_property (Lisp_Object var
)
11243 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
11246 return Voverlay_arrow_string
;
11249 /* Return 1 if there are any overlay-arrows in current_buffer. */
11251 overlay_arrow_in_current_buffer_p (void)
11255 for (vlist
= Voverlay_arrow_variable_list
;
11257 vlist
= XCDR (vlist
))
11259 Lisp_Object var
= XCAR (vlist
);
11262 if (!SYMBOLP (var
))
11264 val
= find_symbol_value (var
);
11266 && current_buffer
== XMARKER (val
)->buffer
)
11273 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
11277 overlay_arrows_changed_p (void)
11281 for (vlist
= Voverlay_arrow_variable_list
;
11283 vlist
= XCDR (vlist
))
11285 Lisp_Object var
= XCAR (vlist
);
11286 Lisp_Object val
, pstr
;
11288 if (!SYMBOLP (var
))
11290 val
= find_symbol_value (var
);
11291 if (!MARKERP (val
))
11293 if (! EQ (COERCE_MARKER (val
),
11294 Fget (var
, Qlast_arrow_position
))
11295 || ! (pstr
= overlay_arrow_string_or_property (var
),
11296 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
11302 /* Mark overlay arrows to be updated on next redisplay. */
11305 update_overlay_arrows (int up_to_date
)
11309 for (vlist
= Voverlay_arrow_variable_list
;
11311 vlist
= XCDR (vlist
))
11313 Lisp_Object var
= XCAR (vlist
);
11315 if (!SYMBOLP (var
))
11318 if (up_to_date
> 0)
11320 Lisp_Object val
= find_symbol_value (var
);
11321 Fput (var
, Qlast_arrow_position
,
11322 COERCE_MARKER (val
));
11323 Fput (var
, Qlast_arrow_string
,
11324 overlay_arrow_string_or_property (var
));
11326 else if (up_to_date
< 0
11327 || !NILP (Fget (var
, Qlast_arrow_position
)))
11329 Fput (var
, Qlast_arrow_position
, Qt
);
11330 Fput (var
, Qlast_arrow_string
, Qt
);
11336 /* Return overlay arrow string to display at row.
11337 Return integer (bitmap number) for arrow bitmap in left fringe.
11338 Return nil if no overlay arrow. */
11341 overlay_arrow_at_row (struct it
*it
, struct glyph_row
*row
)
11345 for (vlist
= Voverlay_arrow_variable_list
;
11347 vlist
= XCDR (vlist
))
11349 Lisp_Object var
= XCAR (vlist
);
11352 if (!SYMBOLP (var
))
11355 val
= find_symbol_value (var
);
11358 && current_buffer
== XMARKER (val
)->buffer
11359 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
11361 if (FRAME_WINDOW_P (it
->f
)
11362 /* FIXME: if ROW->reversed_p is set, this should test
11363 the right fringe, not the left one. */
11364 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
11366 #ifdef HAVE_WINDOW_SYSTEM
11367 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
11370 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
11371 return make_number (fringe_bitmap
);
11374 return make_number (-1); /* Use default arrow bitmap */
11376 return overlay_arrow_string_or_property (var
);
11383 /* Return 1 if point moved out of or into a composition. Otherwise
11384 return 0. PREV_BUF and PREV_PT are the last point buffer and
11385 position. BUF and PT are the current point buffer and position. */
11388 check_point_in_composition (struct buffer
*prev_buf
, EMACS_INT prev_pt
,
11389 struct buffer
*buf
, EMACS_INT pt
)
11391 EMACS_INT start
, end
;
11393 Lisp_Object buffer
;
11395 XSETBUFFER (buffer
, buf
);
11396 /* Check a composition at the last point if point moved within the
11398 if (prev_buf
== buf
)
11401 /* Point didn't move. */
11404 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
11405 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
11406 && COMPOSITION_VALID_P (start
, end
, prop
)
11407 && start
< prev_pt
&& end
> prev_pt
)
11408 /* The last point was within the composition. Return 1 iff
11409 point moved out of the composition. */
11410 return (pt
<= start
|| pt
>= end
);
11413 /* Check a composition at the current point. */
11414 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
11415 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
11416 && COMPOSITION_VALID_P (start
, end
, prop
)
11417 && start
< pt
&& end
> pt
);
11421 /* Reconsider the setting of B->clip_changed which is displayed
11425 reconsider_clip_changes (struct window
*w
, struct buffer
*b
)
11427 if (b
->clip_changed
11428 && !NILP (w
->window_end_valid
)
11429 && w
->current_matrix
->buffer
== b
11430 && w
->current_matrix
->zv
== BUF_ZV (b
)
11431 && w
->current_matrix
->begv
== BUF_BEGV (b
))
11432 b
->clip_changed
= 0;
11434 /* If display wasn't paused, and W is not a tool bar window, see if
11435 point has been moved into or out of a composition. In that case,
11436 we set b->clip_changed to 1 to force updating the screen. If
11437 b->clip_changed has already been set to 1, we can skip this
11439 if (!b
->clip_changed
11440 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
11444 if (w
== XWINDOW (selected_window
))
11447 pt
= marker_position (w
->pointm
);
11449 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
11450 || pt
!= XINT (w
->last_point
))
11451 && check_point_in_composition (w
->current_matrix
->buffer
,
11452 XINT (w
->last_point
),
11453 XBUFFER (w
->buffer
), pt
))
11454 b
->clip_changed
= 1;
11459 /* Select FRAME to forward the values of frame-local variables into C
11460 variables so that the redisplay routines can access those values
11464 select_frame_for_redisplay (Lisp_Object frame
)
11466 Lisp_Object tail
, tem
;
11467 Lisp_Object old
= selected_frame
;
11468 struct Lisp_Symbol
*sym
;
11470 xassert (FRAMEP (frame
) && FRAME_LIVE_P (XFRAME (frame
)));
11472 selected_frame
= frame
;
11475 for (tail
= XFRAME (frame
)->param_alist
; CONSP (tail
); tail
= XCDR (tail
))
11476 if (CONSP (XCAR (tail
))
11477 && (tem
= XCAR (XCAR (tail
)),
11479 && (sym
= indirect_variable (XSYMBOL (tem
)),
11480 sym
->redirect
== SYMBOL_LOCALIZED
)
11481 && sym
->val
.blv
->frame_local
)
11482 /* Use find_symbol_value rather than Fsymbol_value
11483 to avoid an error if it is void. */
11484 find_symbol_value (tem
);
11485 } while (!EQ (frame
, old
) && (frame
= old
, 1));
11489 #define STOP_POLLING \
11490 do { if (! polling_stopped_here) stop_polling (); \
11491 polling_stopped_here = 1; } while (0)
11493 #define RESUME_POLLING \
11494 do { if (polling_stopped_here) start_polling (); \
11495 polling_stopped_here = 0; } while (0)
11498 /* Perhaps in the future avoid recentering windows if it
11499 is not necessary; currently that causes some problems. */
11502 redisplay_internal (void)
11504 struct window
*w
= XWINDOW (selected_window
);
11508 int must_finish
= 0;
11509 struct text_pos tlbufpos
, tlendpos
;
11510 int number_of_visible_frames
;
11513 int polling_stopped_here
= 0;
11514 Lisp_Object old_frame
= selected_frame
;
11516 /* Non-zero means redisplay has to consider all windows on all
11517 frames. Zero means, only selected_window is considered. */
11518 int consider_all_windows_p
;
11520 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
11522 /* No redisplay if running in batch mode or frame is not yet fully
11523 initialized, or redisplay is explicitly turned off by setting
11524 Vinhibit_redisplay. */
11525 if (FRAME_INITIAL_P (SELECTED_FRAME ())
11526 || !NILP (Vinhibit_redisplay
))
11529 /* Don't examine these until after testing Vinhibit_redisplay.
11530 When Emacs is shutting down, perhaps because its connection to
11531 X has dropped, we should not look at them at all. */
11532 fr
= XFRAME (w
->frame
);
11533 sf
= SELECTED_FRAME ();
11535 if (!fr
->glyphs_initialized_p
)
11538 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
11539 if (popup_activated ())
11543 /* I don't think this happens but let's be paranoid. */
11544 if (redisplaying_p
)
11547 /* Record a function that resets redisplaying_p to its old value
11548 when we leave this function. */
11549 count
= SPECPDL_INDEX ();
11550 record_unwind_protect (unwind_redisplay
,
11551 Fcons (make_number (redisplaying_p
), selected_frame
));
11553 specbind (Qinhibit_free_realized_faces
, Qnil
);
11556 Lisp_Object tail
, frame
;
11558 FOR_EACH_FRAME (tail
, frame
)
11560 struct frame
*f
= XFRAME (frame
);
11561 f
->already_hscrolled_p
= 0;
11566 /* Remember the currently selected window. */
11569 if (!EQ (old_frame
, selected_frame
)
11570 && FRAME_LIVE_P (XFRAME (old_frame
)))
11571 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
11572 selected_frame and selected_window to be temporarily out-of-sync so
11573 when we come back here via `goto retry', we need to resync because we
11574 may need to run Elisp code (via prepare_menu_bars). */
11575 select_frame_for_redisplay (old_frame
);
11578 reconsider_clip_changes (w
, current_buffer
);
11579 last_escape_glyph_frame
= NULL
;
11580 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
11581 last_glyphless_glyph_frame
= NULL
;
11582 last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
11584 /* If new fonts have been loaded that make a glyph matrix adjustment
11585 necessary, do it. */
11586 if (fonts_changed_p
)
11588 adjust_glyphs (NULL
);
11589 ++windows_or_buffers_changed
;
11590 fonts_changed_p
= 0;
11593 /* If face_change_count is non-zero, init_iterator will free all
11594 realized faces, which includes the faces referenced from current
11595 matrices. So, we can't reuse current matrices in this case. */
11596 if (face_change_count
)
11597 ++windows_or_buffers_changed
;
11599 if ((FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
11600 && FRAME_TTY (sf
)->previous_frame
!= sf
)
11602 /* Since frames on a single ASCII terminal share the same
11603 display area, displaying a different frame means redisplay
11604 the whole thing. */
11605 windows_or_buffers_changed
++;
11606 SET_FRAME_GARBAGED (sf
);
11608 set_tty_color_mode (FRAME_TTY (sf
), sf
);
11610 FRAME_TTY (sf
)->previous_frame
= sf
;
11613 /* Set the visible flags for all frames. Do this before checking
11614 for resized or garbaged frames; they want to know if their frames
11615 are visible. See the comment in frame.h for
11616 FRAME_SAMPLE_VISIBILITY. */
11618 Lisp_Object tail
, frame
;
11620 number_of_visible_frames
= 0;
11622 FOR_EACH_FRAME (tail
, frame
)
11624 struct frame
*f
= XFRAME (frame
);
11626 FRAME_SAMPLE_VISIBILITY (f
);
11627 if (FRAME_VISIBLE_P (f
))
11628 ++number_of_visible_frames
;
11629 clear_desired_matrices (f
);
11633 /* Notice any pending interrupt request to change frame size. */
11634 do_pending_window_change (1);
11636 /* do_pending_window_change could change the selected_window due to
11637 frame resizing which makes the selected window too small. */
11638 if (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
)
11641 reconsider_clip_changes (w
, current_buffer
);
11644 /* Clear frames marked as garbaged. */
11645 if (frame_garbaged
)
11646 clear_garbaged_frames ();
11648 /* Build menubar and tool-bar items. */
11649 if (NILP (Vmemory_full
))
11650 prepare_menu_bars ();
11652 if (windows_or_buffers_changed
)
11653 update_mode_lines
++;
11655 /* Detect case that we need to write or remove a star in the mode line. */
11656 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
11658 w
->update_mode_line
= Qt
;
11659 if (buffer_shared
> 1)
11660 update_mode_lines
++;
11663 /* Avoid invocation of point motion hooks by `current_column' below. */
11664 count1
= SPECPDL_INDEX ();
11665 specbind (Qinhibit_point_motion_hooks
, Qt
);
11667 /* If %c is in the mode line, update it if needed. */
11668 if (!NILP (w
->column_number_displayed
)
11669 /* This alternative quickly identifies a common case
11670 where no change is needed. */
11671 && !(PT
== XFASTINT (w
->last_point
)
11672 && XFASTINT (w
->last_modified
) >= MODIFF
11673 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
11674 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
11675 w
->update_mode_line
= Qt
;
11677 unbind_to (count1
, Qnil
);
11679 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
11681 /* The variable buffer_shared is set in redisplay_window and
11682 indicates that we redisplay a buffer in different windows. See
11684 consider_all_windows_p
= (update_mode_lines
|| buffer_shared
> 1
11685 || cursor_type_changed
);
11687 /* If specs for an arrow have changed, do thorough redisplay
11688 to ensure we remove any arrow that should no longer exist. */
11689 if (overlay_arrows_changed_p ())
11690 consider_all_windows_p
= windows_or_buffers_changed
= 1;
11692 /* Normally the message* functions will have already displayed and
11693 updated the echo area, but the frame may have been trashed, or
11694 the update may have been preempted, so display the echo area
11695 again here. Checking message_cleared_p captures the case that
11696 the echo area should be cleared. */
11697 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
11698 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
11699 || (message_cleared_p
11700 && minibuf_level
== 0
11701 /* If the mini-window is currently selected, this means the
11702 echo-area doesn't show through. */
11703 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
11705 int window_height_changed_p
= echo_area_display (0);
11708 /* If we don't display the current message, don't clear the
11709 message_cleared_p flag, because, if we did, we wouldn't clear
11710 the echo area in the next redisplay which doesn't preserve
11712 if (!display_last_displayed_message_p
)
11713 message_cleared_p
= 0;
11715 if (fonts_changed_p
)
11717 else if (window_height_changed_p
)
11719 consider_all_windows_p
= 1;
11720 ++update_mode_lines
;
11721 ++windows_or_buffers_changed
;
11723 /* If window configuration was changed, frames may have been
11724 marked garbaged. Clear them or we will experience
11725 surprises wrt scrolling. */
11726 if (frame_garbaged
)
11727 clear_garbaged_frames ();
11730 else if (EQ (selected_window
, minibuf_window
)
11731 && (current_buffer
->clip_changed
11732 || XFASTINT (w
->last_modified
) < MODIFF
11733 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
11734 && resize_mini_window (w
, 0))
11736 /* Resized active mini-window to fit the size of what it is
11737 showing if its contents might have changed. */
11739 /* FIXME: this causes all frames to be updated, which seems unnecessary
11740 since only the current frame needs to be considered. This function needs
11741 to be rewritten with two variables, consider_all_windows and
11742 consider_all_frames. */
11743 consider_all_windows_p
= 1;
11744 ++windows_or_buffers_changed
;
11745 ++update_mode_lines
;
11747 /* If window configuration was changed, frames may have been
11748 marked garbaged. Clear them or we will experience
11749 surprises wrt scrolling. */
11750 if (frame_garbaged
)
11751 clear_garbaged_frames ();
11755 /* If showing the region, and mark has changed, we must redisplay
11756 the whole window. The assignment to this_line_start_pos prevents
11757 the optimization directly below this if-statement. */
11758 if (((!NILP (Vtransient_mark_mode
)
11759 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
11760 != !NILP (w
->region_showing
))
11761 || (!NILP (w
->region_showing
)
11762 && !EQ (w
->region_showing
,
11763 Fmarker_position (BVAR (XBUFFER (w
->buffer
), mark
)))))
11764 CHARPOS (this_line_start_pos
) = 0;
11766 /* Optimize the case that only the line containing the cursor in the
11767 selected window has changed. Variables starting with this_ are
11768 set in display_line and record information about the line
11769 containing the cursor. */
11770 tlbufpos
= this_line_start_pos
;
11771 tlendpos
= this_line_end_pos
;
11772 if (!consider_all_windows_p
11773 && CHARPOS (tlbufpos
) > 0
11774 && NILP (w
->update_mode_line
)
11775 && !current_buffer
->clip_changed
11776 && !current_buffer
->prevent_redisplay_optimizations_p
11777 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
11778 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
11779 /* Make sure recorded data applies to current buffer, etc. */
11780 && this_line_buffer
== current_buffer
11781 && current_buffer
== XBUFFER (w
->buffer
)
11782 && NILP (w
->force_start
)
11783 && NILP (w
->optional_new_start
)
11784 /* Point must be on the line that we have info recorded about. */
11785 && PT
>= CHARPOS (tlbufpos
)
11786 && PT
<= Z
- CHARPOS (tlendpos
)
11787 /* All text outside that line, including its final newline,
11788 must be unchanged. */
11789 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
11790 CHARPOS (tlendpos
)))
11792 if (CHARPOS (tlbufpos
) > BEGV
11793 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
11794 && (CHARPOS (tlbufpos
) == ZV
11795 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
11796 /* Former continuation line has disappeared by becoming empty. */
11798 else if (XFASTINT (w
->last_modified
) < MODIFF
11799 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
11800 || MINI_WINDOW_P (w
))
11802 /* We have to handle the case of continuation around a
11803 wide-column character (see the comment in indent.c around
11806 For instance, in the following case:
11808 -------- Insert --------
11809 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
11810 J_I_ ==> J_I_ `^^' are cursors.
11814 As we have to redraw the line above, we cannot use this
11818 int line_height_before
= this_line_pixel_height
;
11820 /* Note that start_display will handle the case that the
11821 line starting at tlbufpos is a continuation line. */
11822 start_display (&it
, w
, tlbufpos
);
11824 /* Implementation note: It this still necessary? */
11825 if (it
.current_x
!= this_line_start_x
)
11828 TRACE ((stderr
, "trying display optimization 1\n"));
11829 w
->cursor
.vpos
= -1;
11830 overlay_arrow_seen
= 0;
11831 it
.vpos
= this_line_vpos
;
11832 it
.current_y
= this_line_y
;
11833 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
11834 display_line (&it
);
11836 /* If line contains point, is not continued,
11837 and ends at same distance from eob as before, we win. */
11838 if (w
->cursor
.vpos
>= 0
11839 /* Line is not continued, otherwise this_line_start_pos
11840 would have been set to 0 in display_line. */
11841 && CHARPOS (this_line_start_pos
)
11842 /* Line ends as before. */
11843 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
11844 /* Line has same height as before. Otherwise other lines
11845 would have to be shifted up or down. */
11846 && this_line_pixel_height
== line_height_before
)
11848 /* If this is not the window's last line, we must adjust
11849 the charstarts of the lines below. */
11850 if (it
.current_y
< it
.last_visible_y
)
11852 struct glyph_row
*row
11853 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
11854 EMACS_INT delta
, delta_bytes
;
11856 /* We used to distinguish between two cases here,
11857 conditioned by Z - CHARPOS (tlendpos) == ZV, for
11858 when the line ends in a newline or the end of the
11859 buffer's accessible portion. But both cases did
11860 the same, so they were collapsed. */
11862 - CHARPOS (tlendpos
)
11863 - MATRIX_ROW_START_CHARPOS (row
));
11864 delta_bytes
= (Z_BYTE
11865 - BYTEPOS (tlendpos
)
11866 - MATRIX_ROW_START_BYTEPOS (row
));
11868 increment_matrix_positions (w
->current_matrix
,
11869 this_line_vpos
+ 1,
11870 w
->current_matrix
->nrows
,
11871 delta
, delta_bytes
);
11874 /* If this row displays text now but previously didn't,
11875 or vice versa, w->window_end_vpos may have to be
11877 if ((it
.glyph_row
- 1)->displays_text_p
)
11879 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
11880 XSETINT (w
->window_end_vpos
, this_line_vpos
);
11882 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
11883 && this_line_vpos
> 0)
11884 XSETINT (w
->window_end_vpos
, this_line_vpos
- 1);
11885 w
->window_end_valid
= Qnil
;
11887 /* Update hint: No need to try to scroll in update_window. */
11888 w
->desired_matrix
->no_scrolling_p
= 1;
11891 *w
->desired_matrix
->method
= 0;
11892 debug_method_add (w
, "optimization 1");
11894 #ifdef HAVE_WINDOW_SYSTEM
11895 update_window_fringes (w
, 0);
11902 else if (/* Cursor position hasn't changed. */
11903 PT
== XFASTINT (w
->last_point
)
11904 /* Make sure the cursor was last displayed
11905 in this window. Otherwise we have to reposition it. */
11906 && 0 <= w
->cursor
.vpos
11907 && WINDOW_TOTAL_LINES (w
) > w
->cursor
.vpos
)
11911 do_pending_window_change (1);
11912 /* If selected_window changed, redisplay again. */
11913 if (WINDOWP (selected_window
)
11914 && (w
= XWINDOW (selected_window
)) != sw
)
11917 /* We used to always goto end_of_redisplay here, but this
11918 isn't enough if we have a blinking cursor. */
11919 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
11920 goto end_of_redisplay
;
11924 /* If highlighting the region, or if the cursor is in the echo area,
11925 then we can't just move the cursor. */
11926 else if (! (!NILP (Vtransient_mark_mode
)
11927 && !NILP (BVAR (current_buffer
, mark_active
)))
11928 && (EQ (selected_window
, BVAR (current_buffer
, last_selected_window
))
11929 || highlight_nonselected_windows
)
11930 && NILP (w
->region_showing
)
11931 && NILP (Vshow_trailing_whitespace
)
11932 && !cursor_in_echo_area
)
11935 struct glyph_row
*row
;
11937 /* Skip from tlbufpos to PT and see where it is. Note that
11938 PT may be in invisible text. If so, we will end at the
11939 next visible position. */
11940 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
11941 NULL
, DEFAULT_FACE_ID
);
11942 it
.current_x
= this_line_start_x
;
11943 it
.current_y
= this_line_y
;
11944 it
.vpos
= this_line_vpos
;
11946 /* The call to move_it_to stops in front of PT, but
11947 moves over before-strings. */
11948 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
11950 if (it
.vpos
== this_line_vpos
11951 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
11954 xassert (this_line_vpos
== it
.vpos
);
11955 xassert (this_line_y
== it
.current_y
);
11956 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
11958 *w
->desired_matrix
->method
= 0;
11959 debug_method_add (w
, "optimization 3");
11968 /* Text changed drastically or point moved off of line. */
11969 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
11972 CHARPOS (this_line_start_pos
) = 0;
11973 consider_all_windows_p
|= buffer_shared
> 1;
11974 ++clear_face_cache_count
;
11975 #ifdef HAVE_WINDOW_SYSTEM
11976 ++clear_image_cache_count
;
11979 /* Build desired matrices, and update the display. If
11980 consider_all_windows_p is non-zero, do it for all windows on all
11981 frames. Otherwise do it for selected_window, only. */
11983 if (consider_all_windows_p
)
11985 Lisp_Object tail
, frame
;
11987 FOR_EACH_FRAME (tail
, frame
)
11988 XFRAME (frame
)->updated_p
= 0;
11990 /* Recompute # windows showing selected buffer. This will be
11991 incremented each time such a window is displayed. */
11994 FOR_EACH_FRAME (tail
, frame
)
11996 struct frame
*f
= XFRAME (frame
);
11998 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
12000 if (! EQ (frame
, selected_frame
))
12001 /* Select the frame, for the sake of frame-local
12003 select_frame_for_redisplay (frame
);
12005 /* Mark all the scroll bars to be removed; we'll redeem
12006 the ones we want when we redisplay their windows. */
12007 if (FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
12008 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
12010 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
12011 redisplay_windows (FRAME_ROOT_WINDOW (f
));
12013 /* The X error handler may have deleted that frame. */
12014 if (!FRAME_LIVE_P (f
))
12017 /* Any scroll bars which redisplay_windows should have
12018 nuked should now go away. */
12019 if (FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
12020 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
12022 /* If fonts changed, display again. */
12023 /* ??? rms: I suspect it is a mistake to jump all the way
12024 back to retry here. It should just retry this frame. */
12025 if (fonts_changed_p
)
12028 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
12030 /* See if we have to hscroll. */
12031 if (!f
->already_hscrolled_p
)
12033 f
->already_hscrolled_p
= 1;
12034 if (hscroll_windows (f
->root_window
))
12038 /* Prevent various kinds of signals during display
12039 update. stdio is not robust about handling
12040 signals, which can cause an apparent I/O
12042 if (interrupt_input
)
12043 unrequest_sigio ();
12046 /* Update the display. */
12047 set_window_update_flags (XWINDOW (f
->root_window
), 1);
12048 pending
|= update_frame (f
, 0, 0);
12054 if (!EQ (old_frame
, selected_frame
)
12055 && FRAME_LIVE_P (XFRAME (old_frame
)))
12056 /* We played a bit fast-and-loose above and allowed selected_frame
12057 and selected_window to be temporarily out-of-sync but let's make
12058 sure this stays contained. */
12059 select_frame_for_redisplay (old_frame
);
12060 eassert (EQ (XFRAME (selected_frame
)->selected_window
, selected_window
));
12064 /* Do the mark_window_display_accurate after all windows have
12065 been redisplayed because this call resets flags in buffers
12066 which are needed for proper redisplay. */
12067 FOR_EACH_FRAME (tail
, frame
)
12069 struct frame
*f
= XFRAME (frame
);
12072 mark_window_display_accurate (f
->root_window
, 1);
12073 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
12074 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
12079 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
12081 Lisp_Object mini_window
;
12082 struct frame
*mini_frame
;
12084 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
12085 /* Use list_of_error, not Qerror, so that
12086 we catch only errors and don't run the debugger. */
12087 internal_condition_case_1 (redisplay_window_1
, selected_window
,
12089 redisplay_window_error
);
12091 /* Compare desired and current matrices, perform output. */
12094 /* If fonts changed, display again. */
12095 if (fonts_changed_p
)
12098 /* Prevent various kinds of signals during display update.
12099 stdio is not robust about handling signals,
12100 which can cause an apparent I/O error. */
12101 if (interrupt_input
)
12102 unrequest_sigio ();
12105 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
12107 if (hscroll_windows (selected_window
))
12110 XWINDOW (selected_window
)->must_be_updated_p
= 1;
12111 pending
= update_frame (sf
, 0, 0);
12114 /* We may have called echo_area_display at the top of this
12115 function. If the echo area is on another frame, that may
12116 have put text on a frame other than the selected one, so the
12117 above call to update_frame would not have caught it. Catch
12119 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
12120 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
12122 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
12124 XWINDOW (mini_window
)->must_be_updated_p
= 1;
12125 pending
|= update_frame (mini_frame
, 0, 0);
12126 if (!pending
&& hscroll_windows (mini_window
))
12131 /* If display was paused because of pending input, make sure we do a
12132 thorough update the next time. */
12135 /* Prevent the optimization at the beginning of
12136 redisplay_internal that tries a single-line update of the
12137 line containing the cursor in the selected window. */
12138 CHARPOS (this_line_start_pos
) = 0;
12140 /* Let the overlay arrow be updated the next time. */
12141 update_overlay_arrows (0);
12143 /* If we pause after scrolling, some rows in the current
12144 matrices of some windows are not valid. */
12145 if (!WINDOW_FULL_WIDTH_P (w
)
12146 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
12147 update_mode_lines
= 1;
12151 if (!consider_all_windows_p
)
12153 /* This has already been done above if
12154 consider_all_windows_p is set. */
12155 mark_window_display_accurate_1 (w
, 1);
12157 /* Say overlay arrows are up to date. */
12158 update_overlay_arrows (1);
12160 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
12161 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
12164 update_mode_lines
= 0;
12165 windows_or_buffers_changed
= 0;
12166 cursor_type_changed
= 0;
12169 /* Start SIGIO interrupts coming again. Having them off during the
12170 code above makes it less likely one will discard output, but not
12171 impossible, since there might be stuff in the system buffer here.
12172 But it is much hairier to try to do anything about that. */
12173 if (interrupt_input
)
12177 /* If a frame has become visible which was not before, redisplay
12178 again, so that we display it. Expose events for such a frame
12179 (which it gets when becoming visible) don't call the parts of
12180 redisplay constructing glyphs, so simply exposing a frame won't
12181 display anything in this case. So, we have to display these
12182 frames here explicitly. */
12185 Lisp_Object tail
, frame
;
12188 FOR_EACH_FRAME (tail
, frame
)
12190 int this_is_visible
= 0;
12192 if (XFRAME (frame
)->visible
)
12193 this_is_visible
= 1;
12194 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
12195 if (XFRAME (frame
)->visible
)
12196 this_is_visible
= 1;
12198 if (this_is_visible
)
12202 if (new_count
!= number_of_visible_frames
)
12203 windows_or_buffers_changed
++;
12206 /* Change frame size now if a change is pending. */
12207 do_pending_window_change (1);
12209 /* If we just did a pending size change, or have additional
12210 visible frames, or selected_window changed, redisplay again. */
12211 if ((windows_or_buffers_changed
&& !pending
)
12212 || (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
))
12215 /* Clear the face and image caches.
12217 We used to do this only if consider_all_windows_p. But the cache
12218 needs to be cleared if a timer creates images in the current
12219 buffer (e.g. the test case in Bug#6230). */
12221 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
12223 clear_face_cache (0);
12224 clear_face_cache_count
= 0;
12227 #ifdef HAVE_WINDOW_SYSTEM
12228 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
12230 clear_image_caches (Qnil
);
12231 clear_image_cache_count
= 0;
12233 #endif /* HAVE_WINDOW_SYSTEM */
12236 unbind_to (count
, Qnil
);
12241 /* Redisplay, but leave alone any recent echo area message unless
12242 another message has been requested in its place.
12244 This is useful in situations where you need to redisplay but no
12245 user action has occurred, making it inappropriate for the message
12246 area to be cleared. See tracking_off and
12247 wait_reading_process_output for examples of these situations.
12249 FROM_WHERE is an integer saying from where this function was
12250 called. This is useful for debugging. */
12253 redisplay_preserve_echo_area (int from_where
)
12255 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
12257 if (!NILP (echo_area_buffer
[1]))
12259 /* We have a previously displayed message, but no current
12260 message. Redisplay the previous message. */
12261 display_last_displayed_message_p
= 1;
12262 redisplay_internal ();
12263 display_last_displayed_message_p
= 0;
12266 redisplay_internal ();
12268 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
12269 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
12270 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL
);
12274 /* Function registered with record_unwind_protect in
12275 redisplay_internal. Reset redisplaying_p to the value it had
12276 before redisplay_internal was called, and clear
12277 prevent_freeing_realized_faces_p. It also selects the previously
12278 selected frame, unless it has been deleted (by an X connection
12279 failure during redisplay, for example). */
12282 unwind_redisplay (Lisp_Object val
)
12284 Lisp_Object old_redisplaying_p
, old_frame
;
12286 old_redisplaying_p
= XCAR (val
);
12287 redisplaying_p
= XFASTINT (old_redisplaying_p
);
12288 old_frame
= XCDR (val
);
12289 if (! EQ (old_frame
, selected_frame
)
12290 && FRAME_LIVE_P (XFRAME (old_frame
)))
12291 select_frame_for_redisplay (old_frame
);
12296 /* Mark the display of window W as accurate or inaccurate. If
12297 ACCURATE_P is non-zero mark display of W as accurate. If
12298 ACCURATE_P is zero, arrange for W to be redisplayed the next time
12299 redisplay_internal is called. */
12302 mark_window_display_accurate_1 (struct window
*w
, int accurate_p
)
12304 if (BUFFERP (w
->buffer
))
12306 struct buffer
*b
= XBUFFER (w
->buffer
);
12309 = make_number (accurate_p
? BUF_MODIFF (b
) : 0);
12310 w
->last_overlay_modified
12311 = make_number (accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0);
12313 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
) ? Qt
: Qnil
;
12317 b
->clip_changed
= 0;
12318 b
->prevent_redisplay_optimizations_p
= 0;
12320 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
12321 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
12322 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
12323 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
12325 w
->current_matrix
->buffer
= b
;
12326 w
->current_matrix
->begv
= BUF_BEGV (b
);
12327 w
->current_matrix
->zv
= BUF_ZV (b
);
12329 w
->last_cursor
= w
->cursor
;
12330 w
->last_cursor_off_p
= w
->cursor_off_p
;
12332 if (w
== XWINDOW (selected_window
))
12333 w
->last_point
= make_number (BUF_PT (b
));
12335 w
->last_point
= make_number (XMARKER (w
->pointm
)->charpos
);
12341 w
->window_end_valid
= w
->buffer
;
12342 w
->update_mode_line
= Qnil
;
12347 /* Mark the display of windows in the window tree rooted at WINDOW as
12348 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
12349 windows as accurate. If ACCURATE_P is zero, arrange for windows to
12350 be redisplayed the next time redisplay_internal is called. */
12353 mark_window_display_accurate (Lisp_Object window
, int accurate_p
)
12357 for (; !NILP (window
); window
= w
->next
)
12359 w
= XWINDOW (window
);
12360 mark_window_display_accurate_1 (w
, accurate_p
);
12362 if (!NILP (w
->vchild
))
12363 mark_window_display_accurate (w
->vchild
, accurate_p
);
12364 if (!NILP (w
->hchild
))
12365 mark_window_display_accurate (w
->hchild
, accurate_p
);
12370 update_overlay_arrows (1);
12374 /* Force a thorough redisplay the next time by setting
12375 last_arrow_position and last_arrow_string to t, which is
12376 unequal to any useful value of Voverlay_arrow_... */
12377 update_overlay_arrows (-1);
12382 /* Return value in display table DP (Lisp_Char_Table *) for character
12383 C. Since a display table doesn't have any parent, we don't have to
12384 follow parent. Do not call this function directly but use the
12385 macro DISP_CHAR_VECTOR. */
12388 disp_char_vector (struct Lisp_Char_Table
*dp
, int c
)
12392 if (ASCII_CHAR_P (c
))
12395 if (SUB_CHAR_TABLE_P (val
))
12396 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
12402 XSETCHAR_TABLE (table
, dp
);
12403 val
= char_table_ref (table
, c
);
12412 /***********************************************************************
12414 ***********************************************************************/
12416 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
12419 redisplay_windows (Lisp_Object window
)
12421 while (!NILP (window
))
12423 struct window
*w
= XWINDOW (window
);
12425 if (!NILP (w
->hchild
))
12426 redisplay_windows (w
->hchild
);
12427 else if (!NILP (w
->vchild
))
12428 redisplay_windows (w
->vchild
);
12429 else if (!NILP (w
->buffer
))
12431 displayed_buffer
= XBUFFER (w
->buffer
);
12432 /* Use list_of_error, not Qerror, so that
12433 we catch only errors and don't run the debugger. */
12434 internal_condition_case_1 (redisplay_window_0
, window
,
12436 redisplay_window_error
);
12444 redisplay_window_error (Lisp_Object ignore
)
12446 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
12451 redisplay_window_0 (Lisp_Object window
)
12453 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
12454 redisplay_window (window
, 0);
12459 redisplay_window_1 (Lisp_Object window
)
12461 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
12462 redisplay_window (window
, 1);
12467 /* Set cursor position of W. PT is assumed to be displayed in ROW.
12468 DELTA and DELTA_BYTES are the numbers of characters and bytes by
12469 which positions recorded in ROW differ from current buffer
12472 Return 0 if cursor is not on this row, 1 otherwise. */
12475 set_cursor_from_row (struct window
*w
, struct glyph_row
*row
,
12476 struct glyph_matrix
*matrix
,
12477 EMACS_INT delta
, EMACS_INT delta_bytes
,
12480 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
12481 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
12482 struct glyph
*cursor
= NULL
;
12483 /* The last known character position in row. */
12484 EMACS_INT last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
12486 EMACS_INT pt_old
= PT
- delta
;
12487 EMACS_INT pos_before
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
12488 EMACS_INT pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
12489 struct glyph
*glyph_before
= glyph
- 1, *glyph_after
= end
;
12490 /* A glyph beyond the edge of TEXT_AREA which we should never
12492 struct glyph
*glyphs_end
= end
;
12493 /* Non-zero means we've found a match for cursor position, but that
12494 glyph has the avoid_cursor_p flag set. */
12495 int match_with_avoid_cursor
= 0;
12496 /* Non-zero means we've seen at least one glyph that came from a
12498 int string_seen
= 0;
12499 /* Largest and smalles buffer positions seen so far during scan of
12501 EMACS_INT bpos_max
= pos_before
;
12502 EMACS_INT bpos_min
= pos_after
;
12503 /* Last buffer position covered by an overlay string with an integer
12504 `cursor' property. */
12505 EMACS_INT bpos_covered
= 0;
12507 /* Skip over glyphs not having an object at the start and the end of
12508 the row. These are special glyphs like truncation marks on
12509 terminal frames. */
12510 if (row
->displays_text_p
)
12512 if (!row
->reversed_p
)
12515 && INTEGERP (glyph
->object
)
12516 && glyph
->charpos
< 0)
12518 x
+= glyph
->pixel_width
;
12522 && INTEGERP ((end
- 1)->object
)
12523 /* CHARPOS is zero for blanks and stretch glyphs
12524 inserted by extend_face_to_end_of_line. */
12525 && (end
- 1)->charpos
<= 0)
12527 glyph_before
= glyph
- 1;
12534 /* If the glyph row is reversed, we need to process it from back
12535 to front, so swap the edge pointers. */
12536 glyphs_end
= end
= glyph
- 1;
12537 glyph
+= row
->used
[TEXT_AREA
] - 1;
12539 while (glyph
> end
+ 1
12540 && INTEGERP (glyph
->object
)
12541 && glyph
->charpos
< 0)
12544 x
-= glyph
->pixel_width
;
12546 if (INTEGERP (glyph
->object
) && glyph
->charpos
< 0)
12548 /* By default, in reversed rows we put the cursor on the
12549 rightmost (first in the reading order) glyph. */
12550 for (g
= end
+ 1; g
< glyph
; g
++)
12551 x
+= g
->pixel_width
;
12553 && INTEGERP ((end
+ 1)->object
)
12554 && (end
+ 1)->charpos
<= 0)
12556 glyph_before
= glyph
+ 1;
12560 else if (row
->reversed_p
)
12562 /* In R2L rows that don't display text, put the cursor on the
12563 rightmost glyph. Case in point: an empty last line that is
12564 part of an R2L paragraph. */
12566 /* Avoid placing the cursor on the last glyph of the row, where
12567 on terminal frames we hold the vertical border between
12568 adjacent windows. */
12569 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w
))
12570 && !WINDOW_RIGHTMOST_P (w
)
12571 && cursor
== row
->glyphs
[LAST_AREA
] - 1)
12573 x
= -1; /* will be computed below, at label compute_x */
12576 /* Step 1: Try to find the glyph whose character position
12577 corresponds to point. If that's not possible, find 2 glyphs
12578 whose character positions are the closest to point, one before
12579 point, the other after it. */
12580 if (!row
->reversed_p
)
12581 while (/* not marched to end of glyph row */
12583 /* glyph was not inserted by redisplay for internal purposes */
12584 && !INTEGERP (glyph
->object
))
12586 if (BUFFERP (glyph
->object
))
12588 EMACS_INT dpos
= glyph
->charpos
- pt_old
;
12590 if (glyph
->charpos
> bpos_max
)
12591 bpos_max
= glyph
->charpos
;
12592 if (glyph
->charpos
< bpos_min
)
12593 bpos_min
= glyph
->charpos
;
12594 if (!glyph
->avoid_cursor_p
)
12596 /* If we hit point, we've found the glyph on which to
12597 display the cursor. */
12600 match_with_avoid_cursor
= 0;
12603 /* See if we've found a better approximation to
12604 POS_BEFORE or to POS_AFTER. Note that we want the
12605 first (leftmost) glyph of all those that are the
12606 closest from below, and the last (rightmost) of all
12607 those from above. */
12608 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
12610 pos_before
= glyph
->charpos
;
12611 glyph_before
= glyph
;
12613 else if (0 < dpos
&& dpos
<= pos_after
- pt_old
)
12615 pos_after
= glyph
->charpos
;
12616 glyph_after
= glyph
;
12619 else if (dpos
== 0)
12620 match_with_avoid_cursor
= 1;
12622 else if (STRINGP (glyph
->object
))
12624 Lisp_Object chprop
;
12625 EMACS_INT glyph_pos
= glyph
->charpos
;
12627 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
12629 if (INTEGERP (chprop
))
12631 bpos_covered
= bpos_max
+ XINT (chprop
);
12632 /* If the `cursor' property covers buffer positions up
12633 to and including point, we should display cursor on
12634 this glyph. Note that overlays and text properties
12635 with string values stop bidi reordering, so every
12636 buffer position to the left of the string is always
12637 smaller than any position to the right of the
12638 string. Therefore, if a `cursor' property on one
12639 of the string's characters has an integer value, we
12640 will break out of the loop below _before_ we get to
12641 the position match above. IOW, integer values of
12642 the `cursor' property override the "exact match for
12643 point" strategy of positioning the cursor. */
12644 /* Implementation note: bpos_max == pt_old when, e.g.,
12645 we are in an empty line, where bpos_max is set to
12646 MATRIX_ROW_START_CHARPOS, see above. */
12647 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
12656 x
+= glyph
->pixel_width
;
12659 else if (glyph
> end
) /* row is reversed */
12660 while (!INTEGERP (glyph
->object
))
12662 if (BUFFERP (glyph
->object
))
12664 EMACS_INT dpos
= glyph
->charpos
- pt_old
;
12666 if (glyph
->charpos
> bpos_max
)
12667 bpos_max
= glyph
->charpos
;
12668 if (glyph
->charpos
< bpos_min
)
12669 bpos_min
= glyph
->charpos
;
12670 if (!glyph
->avoid_cursor_p
)
12674 match_with_avoid_cursor
= 0;
12677 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
12679 pos_before
= glyph
->charpos
;
12680 glyph_before
= glyph
;
12682 else if (0 < dpos
&& dpos
<= pos_after
- pt_old
)
12684 pos_after
= glyph
->charpos
;
12685 glyph_after
= glyph
;
12688 else if (dpos
== 0)
12689 match_with_avoid_cursor
= 1;
12691 else if (STRINGP (glyph
->object
))
12693 Lisp_Object chprop
;
12694 EMACS_INT glyph_pos
= glyph
->charpos
;
12696 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
12698 if (INTEGERP (chprop
))
12700 bpos_covered
= bpos_max
+ XINT (chprop
);
12701 /* If the `cursor' property covers buffer positions up
12702 to and including point, we should display cursor on
12704 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
12713 if (glyph
== glyphs_end
) /* don't dereference outside TEXT_AREA */
12715 x
--; /* can't use any pixel_width */
12718 x
-= glyph
->pixel_width
;
12721 /* Step 2: If we didn't find an exact match for point, we need to
12722 look for a proper place to put the cursor among glyphs between
12723 GLYPH_BEFORE and GLYPH_AFTER. */
12724 if (!((row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
12725 && BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
12726 && bpos_covered
< pt_old
)
12728 /* An empty line has a single glyph whose OBJECT is zero and
12729 whose CHARPOS is the position of a newline on that line.
12730 Note that on a TTY, there are more glyphs after that, which
12731 were produced by extend_face_to_end_of_line, but their
12732 CHARPOS is zero or negative. */
12734 (row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
12735 && INTEGERP (glyph
->object
) && glyph
->charpos
> 0;
12737 if (row
->ends_in_ellipsis_p
&& pos_after
== last_pos
)
12739 EMACS_INT ellipsis_pos
;
12741 /* Scan back over the ellipsis glyphs. */
12742 if (!row
->reversed_p
)
12744 ellipsis_pos
= (glyph
- 1)->charpos
;
12745 while (glyph
> row
->glyphs
[TEXT_AREA
]
12746 && (glyph
- 1)->charpos
== ellipsis_pos
)
12747 glyph
--, x
-= glyph
->pixel_width
;
12748 /* That loop always goes one position too far, including
12749 the glyph before the ellipsis. So scan forward over
12751 x
+= glyph
->pixel_width
;
12754 else /* row is reversed */
12756 ellipsis_pos
= (glyph
+ 1)->charpos
;
12757 while (glyph
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
12758 && (glyph
+ 1)->charpos
== ellipsis_pos
)
12759 glyph
++, x
+= glyph
->pixel_width
;
12760 x
-= glyph
->pixel_width
;
12764 else if (match_with_avoid_cursor
12765 /* A truncated row may not include PT among its
12766 character positions. Setting the cursor inside the
12767 scroll margin will trigger recalculation of hscroll
12768 in hscroll_window_tree. */
12769 || (row
->truncated_on_left_p
&& pt_old
< bpos_min
)
12770 || (row
->truncated_on_right_p
&& pt_old
> bpos_max
)
12771 /* Zero-width characters produce no glyphs. */
12774 && (row
->reversed_p
12775 ? glyph_after
> glyphs_end
12776 : glyph_after
< glyphs_end
)))
12778 cursor
= glyph_after
;
12781 else if (string_seen
)
12783 int incr
= row
->reversed_p
? -1 : +1;
12785 /* Need to find the glyph that came out of a string which is
12786 present at point. That glyph is somewhere between
12787 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
12788 positioned between POS_BEFORE and POS_AFTER in the
12790 struct glyph
*start
, *stop
;
12791 EMACS_INT pos
= pos_before
;
12795 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
12796 correspond to POS_BEFORE and POS_AFTER, respectively. We
12797 need START and STOP in the order that corresponds to the
12798 row's direction as given by its reversed_p flag. If the
12799 directionality of characters between POS_BEFORE and
12800 POS_AFTER is the opposite of the row's base direction,
12801 these characters will have been reordered for display,
12802 and we need to reverse START and STOP. */
12803 if (!row
->reversed_p
)
12805 start
= min (glyph_before
, glyph_after
);
12806 stop
= max (glyph_before
, glyph_after
);
12810 start
= max (glyph_before
, glyph_after
);
12811 stop
= min (glyph_before
, glyph_after
);
12813 for (glyph
= start
+ incr
;
12814 row
->reversed_p
? glyph
> stop
: glyph
< stop
; )
12817 /* Any glyphs that come from the buffer are here because
12818 of bidi reordering. Skip them, and only pay
12819 attention to glyphs that came from some string. */
12820 if (STRINGP (glyph
->object
))
12825 str
= glyph
->object
;
12826 tem
= string_buffer_position_lim (str
, pos
, pos_after
, 0);
12827 if (tem
== 0 /* from overlay */
12830 /* If the string from which this glyph came is
12831 found in the buffer at point, then we've
12832 found the glyph we've been looking for. If
12833 it comes from an overlay (tem == 0), and it
12834 has the `cursor' property on one of its
12835 glyphs, record that glyph as a candidate for
12836 displaying the cursor. (As in the
12837 unidirectional version, we will display the
12838 cursor on the last candidate we find.) */
12839 if (tem
== 0 || tem
== pt_old
)
12841 /* The glyphs from this string could have
12842 been reordered. Find the one with the
12843 smallest string position. Or there could
12844 be a character in the string with the
12845 `cursor' property, which means display
12846 cursor on that character's glyph. */
12847 EMACS_INT strpos
= glyph
->charpos
;
12852 (row
->reversed_p
? glyph
> stop
: glyph
< stop
)
12853 && EQ (glyph
->object
, str
);
12857 EMACS_INT gpos
= glyph
->charpos
;
12859 cprop
= Fget_char_property (make_number (gpos
),
12867 if (tem
&& glyph
->charpos
< strpos
)
12869 strpos
= glyph
->charpos
;
12878 pos
= tem
+ 1; /* don't find previous instances */
12880 /* This string is not what we want; skip all of the
12881 glyphs that came from it. */
12882 while ((row
->reversed_p
? glyph
> stop
: glyph
< stop
)
12883 && EQ (glyph
->object
, str
))
12890 /* If we reached the end of the line, and END was from a string,
12891 the cursor is not on this line. */
12893 && (row
->reversed_p
? glyph
<= end
: glyph
>= end
)
12894 && STRINGP (end
->object
)
12895 && row
->continued_p
)
12901 if (cursor
!= NULL
)
12907 /* Need to compute x that corresponds to GLYPH. */
12908 for (g
= row
->glyphs
[TEXT_AREA
], x
= row
->x
; g
< glyph
; g
++)
12910 if (g
>= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
])
12912 x
+= g
->pixel_width
;
12916 /* ROW could be part of a continued line, which, under bidi
12917 reordering, might have other rows whose start and end charpos
12918 occlude point. Only set w->cursor if we found a better
12919 approximation to the cursor position than we have from previously
12920 examined candidate rows belonging to the same continued line. */
12921 if (/* we already have a candidate row */
12922 w
->cursor
.vpos
>= 0
12923 /* that candidate is not the row we are processing */
12924 && MATRIX_ROW (matrix
, w
->cursor
.vpos
) != row
12925 /* the row we are processing is part of a continued line */
12926 && (row
->continued_p
|| MATRIX_ROW_CONTINUATION_LINE_P (row
))
12927 /* Make sure cursor.vpos specifies a row whose start and end
12928 charpos occlude point. This is because some callers of this
12929 function leave cursor.vpos at the row where the cursor was
12930 displayed during the last redisplay cycle. */
12931 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)) <= pt_old
12932 && pt_old
< MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)))
12935 MATRIX_ROW_GLYPH_START (matrix
, w
->cursor
.vpos
) + w
->cursor
.hpos
;
12937 /* Don't consider glyphs that are outside TEXT_AREA. */
12938 if (!(row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
))
12940 /* Keep the candidate whose buffer position is the closest to
12942 if (/* previous candidate is a glyph in TEXT_AREA of that row */
12943 w
->cursor
.hpos
>= 0
12944 && w
->cursor
.hpos
< MATRIX_ROW_USED (matrix
, w
->cursor
.vpos
)
12945 && BUFFERP (g1
->object
)
12946 && (g1
->charpos
== pt_old
/* an exact match always wins */
12947 || (BUFFERP (glyph
->object
)
12948 && eabs (g1
->charpos
- pt_old
)
12949 < eabs (glyph
->charpos
- pt_old
))))
12951 /* If this candidate gives an exact match, use that. */
12952 if (!(BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
12953 /* Otherwise, keep the candidate that comes from a row
12954 spanning less buffer positions. This may win when one or
12955 both candidate positions are on glyphs that came from
12956 display strings, for which we cannot compare buffer
12958 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
12959 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
12960 < MATRIX_ROW_END_CHARPOS (row
) - MATRIX_ROW_START_CHARPOS (row
))
12963 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
12965 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
12966 w
->cursor
.y
= row
->y
+ dy
;
12968 if (w
== XWINDOW (selected_window
))
12970 if (!row
->continued_p
12971 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
12974 this_line_buffer
= XBUFFER (w
->buffer
);
12976 CHARPOS (this_line_start_pos
)
12977 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
12978 BYTEPOS (this_line_start_pos
)
12979 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
12981 CHARPOS (this_line_end_pos
)
12982 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
12983 BYTEPOS (this_line_end_pos
)
12984 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
12986 this_line_y
= w
->cursor
.y
;
12987 this_line_pixel_height
= row
->height
;
12988 this_line_vpos
= w
->cursor
.vpos
;
12989 this_line_start_x
= row
->x
;
12992 CHARPOS (this_line_start_pos
) = 0;
12999 /* Run window scroll functions, if any, for WINDOW with new window
13000 start STARTP. Sets the window start of WINDOW to that position.
13002 We assume that the window's buffer is really current. */
13004 static inline struct text_pos
13005 run_window_scroll_functions (Lisp_Object window
, struct text_pos startp
)
13007 struct window
*w
= XWINDOW (window
);
13008 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
13010 if (current_buffer
!= XBUFFER (w
->buffer
))
13013 if (!NILP (Vwindow_scroll_functions
))
13015 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
13016 make_number (CHARPOS (startp
)));
13017 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13018 /* In case the hook functions switch buffers. */
13019 if (current_buffer
!= XBUFFER (w
->buffer
))
13020 set_buffer_internal_1 (XBUFFER (w
->buffer
));
13027 /* Make sure the line containing the cursor is fully visible.
13028 A value of 1 means there is nothing to be done.
13029 (Either the line is fully visible, or it cannot be made so,
13030 or we cannot tell.)
13032 If FORCE_P is non-zero, return 0 even if partial visible cursor row
13033 is higher than window.
13035 A value of 0 means the caller should do scrolling
13036 as if point had gone off the screen. */
13039 cursor_row_fully_visible_p (struct window
*w
, int force_p
, int current_matrix_p
)
13041 struct glyph_matrix
*matrix
;
13042 struct glyph_row
*row
;
13045 if (!make_cursor_line_fully_visible_p
)
13048 /* It's not always possible to find the cursor, e.g, when a window
13049 is full of overlay strings. Don't do anything in that case. */
13050 if (w
->cursor
.vpos
< 0)
13053 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
13054 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
13056 /* If the cursor row is not partially visible, there's nothing to do. */
13057 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
13060 /* If the row the cursor is in is taller than the window's height,
13061 it's not clear what to do, so do nothing. */
13062 window_height
= window_box_height (w
);
13063 if (row
->height
>= window_height
)
13065 if (!force_p
|| MINI_WINDOW_P (w
)
13066 || w
->vscroll
|| w
->cursor
.vpos
== 0)
13073 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
13074 non-zero means only WINDOW is redisplayed in redisplay_internal.
13075 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
13076 in redisplay_window to bring a partially visible line into view in
13077 the case that only the cursor has moved.
13079 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
13080 last screen line's vertical height extends past the end of the screen.
13084 1 if scrolling succeeded
13086 0 if scrolling didn't find point.
13088 -1 if new fonts have been loaded so that we must interrupt
13089 redisplay, adjust glyph matrices, and try again. */
13095 SCROLLING_NEED_LARGER_MATRICES
13098 /* If scroll-conservatively is more than this, never recenter.
13100 If you change this, don't forget to update the doc string of
13101 `scroll-conservatively' and the Emacs manual. */
13102 #define SCROLL_LIMIT 100
13105 try_scrolling (Lisp_Object window
, int just_this_one_p
,
13106 EMACS_INT arg_scroll_conservatively
, EMACS_INT scroll_step
,
13107 int temp_scroll_step
, int last_line_misfit
)
13109 struct window
*w
= XWINDOW (window
);
13110 struct frame
*f
= XFRAME (w
->frame
);
13111 struct text_pos pos
, startp
;
13113 int this_scroll_margin
, scroll_max
, rc
, height
;
13114 int dy
= 0, amount_to_scroll
= 0, scroll_down_p
= 0;
13115 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
13116 Lisp_Object aggressive
;
13117 /* We will never try scrolling more than this number of lines. */
13118 int scroll_limit
= SCROLL_LIMIT
;
13121 debug_method_add (w
, "try_scrolling");
13124 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13126 /* Compute scroll margin height in pixels. We scroll when point is
13127 within this distance from the top or bottom of the window. */
13128 if (scroll_margin
> 0)
13129 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
13130 * FRAME_LINE_HEIGHT (f
);
13132 this_scroll_margin
= 0;
13134 /* Force arg_scroll_conservatively to have a reasonable value, to
13135 avoid scrolling too far away with slow move_it_* functions. Note
13136 that the user can supply scroll-conservatively equal to
13137 `most-positive-fixnum', which can be larger than INT_MAX. */
13138 if (arg_scroll_conservatively
> scroll_limit
)
13140 arg_scroll_conservatively
= scroll_limit
+ 1;
13141 scroll_max
= scroll_limit
* FRAME_LINE_HEIGHT (f
);
13143 else if (scroll_step
|| arg_scroll_conservatively
|| temp_scroll_step
)
13144 /* Compute how much we should try to scroll maximally to bring
13145 point into view. */
13146 scroll_max
= (max (scroll_step
,
13147 max (arg_scroll_conservatively
, temp_scroll_step
))
13148 * FRAME_LINE_HEIGHT (f
));
13149 else if (NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
))
13150 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
)))
13151 /* We're trying to scroll because of aggressive scrolling but no
13152 scroll_step is set. Choose an arbitrary one. */
13153 scroll_max
= 10 * FRAME_LINE_HEIGHT (f
);
13159 /* Decide whether to scroll down. */
13160 if (PT
> CHARPOS (startp
))
13162 int scroll_margin_y
;
13164 /* Compute the pixel ypos of the scroll margin, then move it to
13165 either that ypos or PT, whichever comes first. */
13166 start_display (&it
, w
, startp
);
13167 scroll_margin_y
= it
.last_visible_y
- this_scroll_margin
13168 - FRAME_LINE_HEIGHT (f
) * extra_scroll_margin_lines
;
13169 move_it_to (&it
, PT
, -1, scroll_margin_y
- 1, -1,
13170 (MOVE_TO_POS
| MOVE_TO_Y
));
13172 if (PT
> CHARPOS (it
.current
.pos
))
13174 int y0
= line_bottom_y (&it
);
13175 /* Compute how many pixels below window bottom to stop searching
13176 for PT. This avoids costly search for PT that is far away if
13177 the user limited scrolling by a small number of lines, but
13178 always finds PT if scroll_conservatively is set to a large
13179 number, such as most-positive-fixnum. */
13180 int slack
= max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
));
13181 int y_to_move
= it
.last_visible_y
+ slack
;
13183 /* Compute the distance from the scroll margin to PT or to
13184 the scroll limit, whichever comes first. This should
13185 include the height of the cursor line, to make that line
13187 move_it_to (&it
, PT
, -1, y_to_move
,
13188 -1, MOVE_TO_POS
| MOVE_TO_Y
);
13189 dy
= line_bottom_y (&it
) - y0
;
13191 if (dy
> scroll_max
)
13192 return SCROLLING_FAILED
;
13200 /* Point is in or below the bottom scroll margin, so move the
13201 window start down. If scrolling conservatively, move it just
13202 enough down to make point visible. If scroll_step is set,
13203 move it down by scroll_step. */
13204 if (arg_scroll_conservatively
)
13206 = min (max (dy
, FRAME_LINE_HEIGHT (f
)),
13207 FRAME_LINE_HEIGHT (f
) * arg_scroll_conservatively
);
13208 else if (scroll_step
|| temp_scroll_step
)
13209 amount_to_scroll
= scroll_max
;
13212 aggressive
= BVAR (current_buffer
, scroll_up_aggressively
);
13213 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
13214 if (NUMBERP (aggressive
))
13216 double float_amount
= XFLOATINT (aggressive
) * height
;
13217 amount_to_scroll
= float_amount
;
13218 if (amount_to_scroll
== 0 && float_amount
> 0)
13219 amount_to_scroll
= 1;
13220 /* Don't let point enter the scroll margin near top of
13222 if (amount_to_scroll
> height
- 2*this_scroll_margin
+ dy
)
13223 amount_to_scroll
= height
- 2*this_scroll_margin
+ dy
;
13227 if (amount_to_scroll
<= 0)
13228 return SCROLLING_FAILED
;
13230 start_display (&it
, w
, startp
);
13231 if (arg_scroll_conservatively
<= scroll_limit
)
13232 move_it_vertically (&it
, amount_to_scroll
);
13235 /* Extra precision for users who set scroll-conservatively
13236 to a large number: make sure the amount we scroll
13237 the window start is never less than amount_to_scroll,
13238 which was computed as distance from window bottom to
13239 point. This matters when lines at window top and lines
13240 below window bottom have different height. */
13241 struct it it1
= it
;
13242 /* We use a temporary it1 because line_bottom_y can modify
13243 its argument, if it moves one line down; see there. */
13244 int start_y
= line_bottom_y (&it1
);
13247 move_it_by_lines (&it
, 1);
13249 } while (line_bottom_y (&it1
) - start_y
< amount_to_scroll
);
13252 /* If STARTP is unchanged, move it down another screen line. */
13253 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
13254 move_it_by_lines (&it
, 1);
13255 startp
= it
.current
.pos
;
13259 struct text_pos scroll_margin_pos
= startp
;
13261 /* See if point is inside the scroll margin at the top of the
13263 if (this_scroll_margin
)
13265 start_display (&it
, w
, startp
);
13266 move_it_vertically (&it
, this_scroll_margin
);
13267 scroll_margin_pos
= it
.current
.pos
;
13270 if (PT
< CHARPOS (scroll_margin_pos
))
13272 /* Point is in the scroll margin at the top of the window or
13273 above what is displayed in the window. */
13276 /* Compute the vertical distance from PT to the scroll
13277 margin position. Move as far as scroll_max allows, or
13278 one screenful, or 10 screen lines, whichever is largest.
13279 Give up if distance is greater than scroll_max. */
13280 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
13281 start_display (&it
, w
, pos
);
13283 y_to_move
= max (it
.last_visible_y
,
13284 max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
)));
13285 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
13287 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
13288 dy
= it
.current_y
- y0
;
13289 if (dy
> scroll_max
)
13290 return SCROLLING_FAILED
;
13292 /* Compute new window start. */
13293 start_display (&it
, w
, startp
);
13295 if (arg_scroll_conservatively
)
13296 amount_to_scroll
= max (dy
, FRAME_LINE_HEIGHT (f
) *
13297 max (scroll_step
, temp_scroll_step
));
13298 else if (scroll_step
|| temp_scroll_step
)
13299 amount_to_scroll
= scroll_max
;
13302 aggressive
= BVAR (current_buffer
, scroll_down_aggressively
);
13303 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
13304 if (NUMBERP (aggressive
))
13306 double float_amount
= XFLOATINT (aggressive
) * height
;
13307 amount_to_scroll
= float_amount
;
13308 if (amount_to_scroll
== 0 && float_amount
> 0)
13309 amount_to_scroll
= 1;
13310 amount_to_scroll
-=
13311 this_scroll_margin
- dy
- FRAME_LINE_HEIGHT (f
);
13312 /* Don't let point enter the scroll margin near
13313 bottom of the window. */
13314 if (amount_to_scroll
> height
- 2*this_scroll_margin
+ dy
)
13315 amount_to_scroll
= height
- 2*this_scroll_margin
+ dy
;
13319 if (amount_to_scroll
<= 0)
13320 return SCROLLING_FAILED
;
13322 move_it_vertically_backward (&it
, amount_to_scroll
);
13323 startp
= it
.current
.pos
;
13327 /* Run window scroll functions. */
13328 startp
= run_window_scroll_functions (window
, startp
);
13330 /* Display the window. Give up if new fonts are loaded, or if point
13332 if (!try_window (window
, startp
, 0))
13333 rc
= SCROLLING_NEED_LARGER_MATRICES
;
13334 else if (w
->cursor
.vpos
< 0)
13336 clear_glyph_matrix (w
->desired_matrix
);
13337 rc
= SCROLLING_FAILED
;
13341 /* Maybe forget recorded base line for line number display. */
13342 if (!just_this_one_p
13343 || current_buffer
->clip_changed
13344 || BEG_UNCHANGED
< CHARPOS (startp
))
13345 w
->base_line_number
= Qnil
;
13347 /* If cursor ends up on a partially visible line,
13348 treat that as being off the bottom of the screen. */
13349 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0)
13350 /* It's possible that the cursor is on the first line of the
13351 buffer, which is partially obscured due to a vscroll
13352 (Bug#7537). In that case, avoid looping forever . */
13353 && extra_scroll_margin_lines
< w
->desired_matrix
->nrows
- 1)
13355 clear_glyph_matrix (w
->desired_matrix
);
13356 ++extra_scroll_margin_lines
;
13359 rc
= SCROLLING_SUCCESS
;
13366 /* Compute a suitable window start for window W if display of W starts
13367 on a continuation line. Value is non-zero if a new window start
13370 The new window start will be computed, based on W's width, starting
13371 from the start of the continued line. It is the start of the
13372 screen line with the minimum distance from the old start W->start. */
13375 compute_window_start_on_continuation_line (struct window
*w
)
13377 struct text_pos pos
, start_pos
;
13378 int window_start_changed_p
= 0;
13380 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
13382 /* If window start is on a continuation line... Window start may be
13383 < BEGV in case there's invisible text at the start of the
13384 buffer (M-x rmail, for example). */
13385 if (CHARPOS (start_pos
) > BEGV
13386 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
13389 struct glyph_row
*row
;
13391 /* Handle the case that the window start is out of range. */
13392 if (CHARPOS (start_pos
) < BEGV
)
13393 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
13394 else if (CHARPOS (start_pos
) > ZV
)
13395 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
13397 /* Find the start of the continued line. This should be fast
13398 because scan_buffer is fast (newline cache). */
13399 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
13400 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
13401 row
, DEFAULT_FACE_ID
);
13402 reseat_at_previous_visible_line_start (&it
);
13404 /* If the line start is "too far" away from the window start,
13405 say it takes too much time to compute a new window start. */
13406 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
13407 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
13409 int min_distance
, distance
;
13411 /* Move forward by display lines to find the new window
13412 start. If window width was enlarged, the new start can
13413 be expected to be > the old start. If window width was
13414 decreased, the new window start will be < the old start.
13415 So, we're looking for the display line start with the
13416 minimum distance from the old window start. */
13417 pos
= it
.current
.pos
;
13418 min_distance
= INFINITY
;
13419 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
13420 distance
< min_distance
)
13422 min_distance
= distance
;
13423 pos
= it
.current
.pos
;
13424 move_it_by_lines (&it
, 1);
13427 /* Set the window start there. */
13428 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
13429 window_start_changed_p
= 1;
13433 return window_start_changed_p
;
13437 /* Try cursor movement in case text has not changed in window WINDOW,
13438 with window start STARTP. Value is
13440 CURSOR_MOVEMENT_SUCCESS if successful
13442 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
13444 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
13445 display. *SCROLL_STEP is set to 1, under certain circumstances, if
13446 we want to scroll as if scroll-step were set to 1. See the code.
13448 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
13449 which case we have to abort this redisplay, and adjust matrices
13454 CURSOR_MOVEMENT_SUCCESS
,
13455 CURSOR_MOVEMENT_CANNOT_BE_USED
,
13456 CURSOR_MOVEMENT_MUST_SCROLL
,
13457 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
13461 try_cursor_movement (Lisp_Object window
, struct text_pos startp
, int *scroll_step
)
13463 struct window
*w
= XWINDOW (window
);
13464 struct frame
*f
= XFRAME (w
->frame
);
13465 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
13468 if (inhibit_try_cursor_movement
)
13472 /* Handle case where text has not changed, only point, and it has
13473 not moved off the frame. */
13474 if (/* Point may be in this window. */
13475 PT
>= CHARPOS (startp
)
13476 /* Selective display hasn't changed. */
13477 && !current_buffer
->clip_changed
13478 /* Function force-mode-line-update is used to force a thorough
13479 redisplay. It sets either windows_or_buffers_changed or
13480 update_mode_lines. So don't take a shortcut here for these
13482 && !update_mode_lines
13483 && !windows_or_buffers_changed
13484 && !cursor_type_changed
13485 /* Can't use this case if highlighting a region. When a
13486 region exists, cursor movement has to do more than just
13488 && !(!NILP (Vtransient_mark_mode
)
13489 && !NILP (BVAR (current_buffer
, mark_active
)))
13490 && NILP (w
->region_showing
)
13491 && NILP (Vshow_trailing_whitespace
)
13492 /* Right after splitting windows, last_point may be nil. */
13493 && INTEGERP (w
->last_point
)
13494 /* This code is not used for mini-buffer for the sake of the case
13495 of redisplaying to replace an echo area message; since in
13496 that case the mini-buffer contents per se are usually
13497 unchanged. This code is of no real use in the mini-buffer
13498 since the handling of this_line_start_pos, etc., in redisplay
13499 handles the same cases. */
13500 && !EQ (window
, minibuf_window
)
13501 /* When splitting windows or for new windows, it happens that
13502 redisplay is called with a nil window_end_vpos or one being
13503 larger than the window. This should really be fixed in
13504 window.c. I don't have this on my list, now, so we do
13505 approximately the same as the old redisplay code. --gerd. */
13506 && INTEGERP (w
->window_end_vpos
)
13507 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
13508 && (FRAME_WINDOW_P (f
)
13509 || !overlay_arrow_in_current_buffer_p ()))
13511 int this_scroll_margin
, top_scroll_margin
;
13512 struct glyph_row
*row
= NULL
;
13515 debug_method_add (w
, "cursor movement");
13518 /* Scroll if point within this distance from the top or bottom
13519 of the window. This is a pixel value. */
13520 if (scroll_margin
> 0)
13522 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
13523 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
13526 this_scroll_margin
= 0;
13528 top_scroll_margin
= this_scroll_margin
;
13529 if (WINDOW_WANTS_HEADER_LINE_P (w
))
13530 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
13532 /* Start with the row the cursor was displayed during the last
13533 not paused redisplay. Give up if that row is not valid. */
13534 if (w
->last_cursor
.vpos
< 0
13535 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
13536 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13539 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
13540 if (row
->mode_line_p
)
13542 if (!row
->enabled_p
)
13543 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13546 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
13548 int scroll_p
= 0, must_scroll
= 0;
13549 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
13551 if (PT
> XFASTINT (w
->last_point
))
13553 /* Point has moved forward. */
13554 while (MATRIX_ROW_END_CHARPOS (row
) < PT
13555 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
13557 xassert (row
->enabled_p
);
13561 /* If the end position of a row equals the start
13562 position of the next row, and PT is at that position,
13563 we would rather display cursor in the next line. */
13564 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
13565 && MATRIX_ROW_END_CHARPOS (row
) == PT
13566 && row
< w
->current_matrix
->rows
13567 + w
->current_matrix
->nrows
- 1
13568 && MATRIX_ROW_START_CHARPOS (row
+1) == PT
13569 && !cursor_row_p (row
))
13572 /* If within the scroll margin, scroll. Note that
13573 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
13574 the next line would be drawn, and that
13575 this_scroll_margin can be zero. */
13576 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
13577 || PT
> MATRIX_ROW_END_CHARPOS (row
)
13578 /* Line is completely visible last line in window
13579 and PT is to be set in the next line. */
13580 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
13581 && PT
== MATRIX_ROW_END_CHARPOS (row
)
13582 && !row
->ends_at_zv_p
13583 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
13586 else if (PT
< XFASTINT (w
->last_point
))
13588 /* Cursor has to be moved backward. Note that PT >=
13589 CHARPOS (startp) because of the outer if-statement. */
13590 while (!row
->mode_line_p
13591 && (MATRIX_ROW_START_CHARPOS (row
) > PT
13592 || (MATRIX_ROW_START_CHARPOS (row
) == PT
13593 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
13594 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
13595 row
> w
->current_matrix
->rows
13596 && (row
-1)->ends_in_newline_from_string_p
))))
13597 && (row
->y
> top_scroll_margin
13598 || CHARPOS (startp
) == BEGV
))
13600 xassert (row
->enabled_p
);
13604 /* Consider the following case: Window starts at BEGV,
13605 there is invisible, intangible text at BEGV, so that
13606 display starts at some point START > BEGV. It can
13607 happen that we are called with PT somewhere between
13608 BEGV and START. Try to handle that case. */
13609 if (row
< w
->current_matrix
->rows
13610 || row
->mode_line_p
)
13612 row
= w
->current_matrix
->rows
;
13613 if (row
->mode_line_p
)
13617 /* Due to newlines in overlay strings, we may have to
13618 skip forward over overlay strings. */
13619 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
13620 && MATRIX_ROW_END_CHARPOS (row
) == PT
13621 && !cursor_row_p (row
))
13624 /* If within the scroll margin, scroll. */
13625 if (row
->y
< top_scroll_margin
13626 && CHARPOS (startp
) != BEGV
)
13631 /* Cursor did not move. So don't scroll even if cursor line
13632 is partially visible, as it was so before. */
13633 rc
= CURSOR_MOVEMENT_SUCCESS
;
13636 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
13637 || PT
> MATRIX_ROW_END_CHARPOS (row
))
13639 /* if PT is not in the glyph row, give up. */
13640 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13643 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
13644 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
13646 /* If rows are bidi-reordered and point moved, back up
13647 until we find a row that does not belong to a
13648 continuation line. This is because we must consider
13649 all rows of a continued line as candidates for the
13650 new cursor positioning, since row start and end
13651 positions change non-linearly with vertical position
13653 /* FIXME: Revisit this when glyph ``spilling'' in
13654 continuation lines' rows is implemented for
13655 bidi-reordered rows. */
13656 while (MATRIX_ROW_CONTINUATION_LINE_P (row
))
13658 xassert (row
->enabled_p
);
13660 /* If we hit the beginning of the displayed portion
13661 without finding the first row of a continued
13663 if (row
<= w
->current_matrix
->rows
)
13665 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13673 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
13674 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
13675 && make_cursor_line_fully_visible_p
)
13677 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
13678 && !row
->ends_at_zv_p
13679 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
13680 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13681 else if (row
->height
> window_box_height (w
))
13683 /* If we end up in a partially visible line, let's
13684 make it fully visible, except when it's taller
13685 than the window, in which case we can't do much
13688 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13692 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
13693 if (!cursor_row_fully_visible_p (w
, 0, 1))
13694 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13696 rc
= CURSOR_MOVEMENT_SUCCESS
;
13700 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13701 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
13702 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
13704 /* With bidi-reordered rows, there could be more than
13705 one candidate row whose start and end positions
13706 occlude point. We need to let set_cursor_from_row
13707 find the best candidate. */
13708 /* FIXME: Revisit this when glyph ``spilling'' in
13709 continuation lines' rows is implemented for
13710 bidi-reordered rows. */
13715 if (MATRIX_ROW_START_CHARPOS (row
) <= PT
13716 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
13717 && cursor_row_p (row
))
13718 rv
|= set_cursor_from_row (w
, row
, w
->current_matrix
,
13720 /* As soon as we've found the first suitable row
13721 whose ends_at_zv_p flag is set, we are done. */
13723 && MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
)->ends_at_zv_p
)
13725 rc
= CURSOR_MOVEMENT_SUCCESS
;
13730 while ((MATRIX_ROW_CONTINUATION_LINE_P (row
)
13731 && MATRIX_ROW_BOTTOM_Y (row
) <= last_y
)
13732 || (MATRIX_ROW_START_CHARPOS (row
) == PT
13733 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
));
13734 /* If we didn't find any candidate rows, or exited the
13735 loop before all the candidates were examined, signal
13736 to the caller that this method failed. */
13737 if (rc
!= CURSOR_MOVEMENT_SUCCESS
13738 && (!rv
|| MATRIX_ROW_CONTINUATION_LINE_P (row
)))
13739 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
13741 rc
= CURSOR_MOVEMENT_SUCCESS
;
13747 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
13749 rc
= CURSOR_MOVEMENT_SUCCESS
;
13754 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
13755 && MATRIX_ROW_START_CHARPOS (row
) == PT
13756 && cursor_row_p (row
));
13764 #if !defined USE_TOOLKIT_SCROLL_BARS || defined USE_GTK
13768 set_vertical_scroll_bar (struct window
*w
)
13770 EMACS_INT start
, end
, whole
;
13772 /* Calculate the start and end positions for the current window.
13773 At some point, it would be nice to choose between scrollbars
13774 which reflect the whole buffer size, with special markers
13775 indicating narrowing, and scrollbars which reflect only the
13778 Note that mini-buffers sometimes aren't displaying any text. */
13779 if (!MINI_WINDOW_P (w
)
13780 || (w
== XWINDOW (minibuf_window
)
13781 && NILP (echo_area_buffer
[0])))
13783 struct buffer
*buf
= XBUFFER (w
->buffer
);
13784 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
13785 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
13786 /* I don't think this is guaranteed to be right. For the
13787 moment, we'll pretend it is. */
13788 end
= BUF_Z (buf
) - XFASTINT (w
->window_end_pos
) - BUF_BEGV (buf
);
13792 if (whole
< (end
- start
))
13793 whole
= end
- start
;
13796 start
= end
= whole
= 0;
13798 /* Indicate what this scroll bar ought to be displaying now. */
13799 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
13800 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
13801 (w
, end
- start
, whole
, start
);
13805 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
13806 selected_window is redisplayed.
13808 We can return without actually redisplaying the window if
13809 fonts_changed_p is nonzero. In that case, redisplay_internal will
13813 redisplay_window (Lisp_Object window
, int just_this_one_p
)
13815 struct window
*w
= XWINDOW (window
);
13816 struct frame
*f
= XFRAME (w
->frame
);
13817 struct buffer
*buffer
= XBUFFER (w
->buffer
);
13818 struct buffer
*old
= current_buffer
;
13819 struct text_pos lpoint
, opoint
, startp
;
13820 int update_mode_line
;
13823 /* Record it now because it's overwritten. */
13824 int current_matrix_up_to_date_p
= 0;
13825 int used_current_matrix_p
= 0;
13826 /* This is less strict than current_matrix_up_to_date_p.
13827 It indictes that the buffer contents and narrowing are unchanged. */
13828 int buffer_unchanged_p
= 0;
13829 int temp_scroll_step
= 0;
13830 int count
= SPECPDL_INDEX ();
13832 int centering_position
= -1;
13833 int last_line_misfit
= 0;
13834 EMACS_INT beg_unchanged
, end_unchanged
;
13836 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
13839 /* W must be a leaf window here. */
13840 xassert (!NILP (w
->buffer
));
13842 *w
->desired_matrix
->method
= 0;
13846 reconsider_clip_changes (w
, buffer
);
13848 /* Has the mode line to be updated? */
13849 update_mode_line
= (!NILP (w
->update_mode_line
)
13850 || update_mode_lines
13851 || buffer
->clip_changed
13852 || buffer
->prevent_redisplay_optimizations_p
);
13854 if (MINI_WINDOW_P (w
))
13856 if (w
== XWINDOW (echo_area_window
)
13857 && !NILP (echo_area_buffer
[0]))
13859 if (update_mode_line
)
13860 /* We may have to update a tty frame's menu bar or a
13861 tool-bar. Example `M-x C-h C-h C-g'. */
13862 goto finish_menu_bars
;
13864 /* We've already displayed the echo area glyphs in this window. */
13865 goto finish_scroll_bars
;
13867 else if ((w
!= XWINDOW (minibuf_window
)
13868 || minibuf_level
== 0)
13869 /* When buffer is nonempty, redisplay window normally. */
13870 && BUF_Z (XBUFFER (w
->buffer
)) == BUF_BEG (XBUFFER (w
->buffer
))
13871 /* Quail displays non-mini buffers in minibuffer window.
13872 In that case, redisplay the window normally. */
13873 && !NILP (Fmemq (w
->buffer
, Vminibuffer_list
)))
13875 /* W is a mini-buffer window, but it's not active, so clear
13877 int yb
= window_text_bottom_y (w
);
13878 struct glyph_row
*row
;
13881 for (y
= 0, row
= w
->desired_matrix
->rows
;
13883 y
+= row
->height
, ++row
)
13884 blank_row (w
, row
, y
);
13885 goto finish_scroll_bars
;
13888 clear_glyph_matrix (w
->desired_matrix
);
13891 /* Otherwise set up data on this window; select its buffer and point
13893 /* Really select the buffer, for the sake of buffer-local
13895 set_buffer_internal_1 (XBUFFER (w
->buffer
));
13897 current_matrix_up_to_date_p
13898 = (!NILP (w
->window_end_valid
)
13899 && !current_buffer
->clip_changed
13900 && !current_buffer
->prevent_redisplay_optimizations_p
13901 && XFASTINT (w
->last_modified
) >= MODIFF
13902 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
13904 /* Run the window-bottom-change-functions
13905 if it is possible that the text on the screen has changed
13906 (either due to modification of the text, or any other reason). */
13907 if (!current_matrix_up_to_date_p
13908 && !NILP (Vwindow_text_change_functions
))
13910 safe_run_hooks (Qwindow_text_change_functions
);
13914 beg_unchanged
= BEG_UNCHANGED
;
13915 end_unchanged
= END_UNCHANGED
;
13917 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
13919 specbind (Qinhibit_point_motion_hooks
, Qt
);
13922 = (!NILP (w
->window_end_valid
)
13923 && !current_buffer
->clip_changed
13924 && XFASTINT (w
->last_modified
) >= MODIFF
13925 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
13927 /* When windows_or_buffers_changed is non-zero, we can't rely on
13928 the window end being valid, so set it to nil there. */
13929 if (windows_or_buffers_changed
)
13931 /* If window starts on a continuation line, maybe adjust the
13932 window start in case the window's width changed. */
13933 if (XMARKER (w
->start
)->buffer
== current_buffer
)
13934 compute_window_start_on_continuation_line (w
);
13936 w
->window_end_valid
= Qnil
;
13939 /* Some sanity checks. */
13940 CHECK_WINDOW_END (w
);
13941 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
13943 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
13946 /* If %c is in mode line, update it if needed. */
13947 if (!NILP (w
->column_number_displayed
)
13948 /* This alternative quickly identifies a common case
13949 where no change is needed. */
13950 && !(PT
== XFASTINT (w
->last_point
)
13951 && XFASTINT (w
->last_modified
) >= MODIFF
13952 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
13953 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
13954 update_mode_line
= 1;
13956 /* Count number of windows showing the selected buffer. An indirect
13957 buffer counts as its base buffer. */
13958 if (!just_this_one_p
)
13960 struct buffer
*current_base
, *window_base
;
13961 current_base
= current_buffer
;
13962 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
13963 if (current_base
->base_buffer
)
13964 current_base
= current_base
->base_buffer
;
13965 if (window_base
->base_buffer
)
13966 window_base
= window_base
->base_buffer
;
13967 if (current_base
== window_base
)
13971 /* Point refers normally to the selected window. For any other
13972 window, set up appropriate value. */
13973 if (!EQ (window
, selected_window
))
13975 EMACS_INT new_pt
= XMARKER (w
->pointm
)->charpos
;
13976 EMACS_INT new_pt_byte
= marker_byte_position (w
->pointm
);
13980 new_pt_byte
= BEGV_BYTE
;
13981 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
13983 else if (new_pt
> (ZV
- 1))
13986 new_pt_byte
= ZV_BYTE
;
13987 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
13990 /* We don't use SET_PT so that the point-motion hooks don't run. */
13991 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
13994 /* If any of the character widths specified in the display table
13995 have changed, invalidate the width run cache. It's true that
13996 this may be a bit late to catch such changes, but the rest of
13997 redisplay goes (non-fatally) haywire when the display table is
13998 changed, so why should we worry about doing any better? */
13999 if (current_buffer
->width_run_cache
)
14001 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
14003 if (! disptab_matches_widthtab (disptab
,
14004 XVECTOR (BVAR (current_buffer
, width_table
))))
14006 invalidate_region_cache (current_buffer
,
14007 current_buffer
->width_run_cache
,
14009 recompute_width_table (current_buffer
, disptab
);
14013 /* If window-start is screwed up, choose a new one. */
14014 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
14017 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14019 /* If someone specified a new starting point but did not insist,
14020 check whether it can be used. */
14021 if (!NILP (w
->optional_new_start
)
14022 && CHARPOS (startp
) >= BEGV
14023 && CHARPOS (startp
) <= ZV
)
14025 w
->optional_new_start
= Qnil
;
14026 start_display (&it
, w
, startp
);
14027 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
14028 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
14029 if (IT_CHARPOS (it
) == PT
)
14030 w
->force_start
= Qt
;
14031 /* IT may overshoot PT if text at PT is invisible. */
14032 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
14033 w
->force_start
= Qt
;
14038 /* Handle case where place to start displaying has been specified,
14039 unless the specified location is outside the accessible range. */
14040 if (!NILP (w
->force_start
)
14041 || w
->frozen_window_start_p
)
14043 /* We set this later on if we have to adjust point. */
14046 w
->force_start
= Qnil
;
14048 w
->window_end_valid
= Qnil
;
14050 /* Forget any recorded base line for line number display. */
14051 if (!buffer_unchanged_p
)
14052 w
->base_line_number
= Qnil
;
14054 /* Redisplay the mode line. Select the buffer properly for that.
14055 Also, run the hook window-scroll-functions
14056 because we have scrolled. */
14057 /* Note, we do this after clearing force_start because
14058 if there's an error, it is better to forget about force_start
14059 than to get into an infinite loop calling the hook functions
14060 and having them get more errors. */
14061 if (!update_mode_line
14062 || ! NILP (Vwindow_scroll_functions
))
14064 update_mode_line
= 1;
14065 w
->update_mode_line
= Qt
;
14066 startp
= run_window_scroll_functions (window
, startp
);
14069 w
->last_modified
= make_number (0);
14070 w
->last_overlay_modified
= make_number (0);
14071 if (CHARPOS (startp
) < BEGV
)
14072 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
14073 else if (CHARPOS (startp
) > ZV
)
14074 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
14076 /* Redisplay, then check if cursor has been set during the
14077 redisplay. Give up if new fonts were loaded. */
14078 /* We used to issue a CHECK_MARGINS argument to try_window here,
14079 but this causes scrolling to fail when point begins inside
14080 the scroll margin (bug#148) -- cyd */
14081 if (!try_window (window
, startp
, 0))
14083 w
->force_start
= Qt
;
14084 clear_glyph_matrix (w
->desired_matrix
);
14085 goto need_larger_matrices
;
14088 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
14090 /* If point does not appear, try to move point so it does
14091 appear. The desired matrix has been built above, so we
14092 can use it here. */
14093 new_vpos
= window_box_height (w
) / 2;
14096 if (!cursor_row_fully_visible_p (w
, 0, 0))
14098 /* Point does appear, but on a line partly visible at end of window.
14099 Move it back to a fully-visible line. */
14100 new_vpos
= window_box_height (w
);
14103 /* If we need to move point for either of the above reasons,
14104 now actually do it. */
14107 struct glyph_row
*row
;
14109 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
14110 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
14113 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
14114 MATRIX_ROW_START_BYTEPOS (row
));
14116 if (w
!= XWINDOW (selected_window
))
14117 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
14118 else if (current_buffer
== old
)
14119 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
14121 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
14123 /* If we are highlighting the region, then we just changed
14124 the region, so redisplay to show it. */
14125 if (!NILP (Vtransient_mark_mode
)
14126 && !NILP (BVAR (current_buffer
, mark_active
)))
14128 clear_glyph_matrix (w
->desired_matrix
);
14129 if (!try_window (window
, startp
, 0))
14130 goto need_larger_matrices
;
14135 debug_method_add (w
, "forced window start");
14140 /* Handle case where text has not changed, only point, and it has
14141 not moved off the frame, and we are not retrying after hscroll.
14142 (current_matrix_up_to_date_p is nonzero when retrying.) */
14143 if (current_matrix_up_to_date_p
14144 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
14145 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
14149 case CURSOR_MOVEMENT_SUCCESS
:
14150 used_current_matrix_p
= 1;
14153 case CURSOR_MOVEMENT_MUST_SCROLL
:
14154 goto try_to_scroll
;
14160 /* If current starting point was originally the beginning of a line
14161 but no longer is, find a new starting point. */
14162 else if (!NILP (w
->start_at_line_beg
)
14163 && !(CHARPOS (startp
) <= BEGV
14164 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
14167 debug_method_add (w
, "recenter 1");
14172 /* Try scrolling with try_window_id. Value is > 0 if update has
14173 been done, it is -1 if we know that the same window start will
14174 not work. It is 0 if unsuccessful for some other reason. */
14175 else if ((tem
= try_window_id (w
)) != 0)
14178 debug_method_add (w
, "try_window_id %d", tem
);
14181 if (fonts_changed_p
)
14182 goto need_larger_matrices
;
14186 /* Otherwise try_window_id has returned -1 which means that we
14187 don't want the alternative below this comment to execute. */
14189 else if (CHARPOS (startp
) >= BEGV
14190 && CHARPOS (startp
) <= ZV
14191 && PT
>= CHARPOS (startp
)
14192 && (CHARPOS (startp
) < ZV
14193 /* Avoid starting at end of buffer. */
14194 || CHARPOS (startp
) == BEGV
14195 || (XFASTINT (w
->last_modified
) >= MODIFF
14196 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
14199 /* If first window line is a continuation line, and window start
14200 is inside the modified region, but the first change is before
14201 current window start, we must select a new window start.
14203 However, if this is the result of a down-mouse event (e.g. by
14204 extending the mouse-drag-overlay), we don't want to select a
14205 new window start, since that would change the position under
14206 the mouse, resulting in an unwanted mouse-movement rather
14207 than a simple mouse-click. */
14208 if (NILP (w
->start_at_line_beg
)
14209 && NILP (do_mouse_tracking
)
14210 && CHARPOS (startp
) > BEGV
14211 && CHARPOS (startp
) > BEG
+ beg_unchanged
14212 && CHARPOS (startp
) <= Z
- end_unchanged
14213 /* Even if w->start_at_line_beg is nil, a new window may
14214 start at a line_beg, since that's how set_buffer_window
14215 sets it. So, we need to check the return value of
14216 compute_window_start_on_continuation_line. (See also
14218 && XMARKER (w
->start
)->buffer
== current_buffer
14219 && compute_window_start_on_continuation_line (w
))
14221 w
->force_start
= Qt
;
14222 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14227 debug_method_add (w
, "same window start");
14230 /* Try to redisplay starting at same place as before.
14231 If point has not moved off frame, accept the results. */
14232 if (!current_matrix_up_to_date_p
14233 /* Don't use try_window_reusing_current_matrix in this case
14234 because a window scroll function can have changed the
14236 || !NILP (Vwindow_scroll_functions
)
14237 || MINI_WINDOW_P (w
)
14238 || !(used_current_matrix_p
14239 = try_window_reusing_current_matrix (w
)))
14241 IF_DEBUG (debug_method_add (w
, "1"));
14242 if (try_window (window
, startp
, TRY_WINDOW_CHECK_MARGINS
) < 0)
14243 /* -1 means we need to scroll.
14244 0 means we need new matrices, but fonts_changed_p
14245 is set in that case, so we will detect it below. */
14246 goto try_to_scroll
;
14249 if (fonts_changed_p
)
14250 goto need_larger_matrices
;
14252 if (w
->cursor
.vpos
>= 0)
14254 if (!just_this_one_p
14255 || current_buffer
->clip_changed
14256 || BEG_UNCHANGED
< CHARPOS (startp
))
14257 /* Forget any recorded base line for line number display. */
14258 w
->base_line_number
= Qnil
;
14260 if (!cursor_row_fully_visible_p (w
, 1, 0))
14262 clear_glyph_matrix (w
->desired_matrix
);
14263 last_line_misfit
= 1;
14265 /* Drop through and scroll. */
14270 clear_glyph_matrix (w
->desired_matrix
);
14275 w
->last_modified
= make_number (0);
14276 w
->last_overlay_modified
= make_number (0);
14278 /* Redisplay the mode line. Select the buffer properly for that. */
14279 if (!update_mode_line
)
14281 update_mode_line
= 1;
14282 w
->update_mode_line
= Qt
;
14285 /* Try to scroll by specified few lines. */
14286 if ((scroll_conservatively
14287 || emacs_scroll_step
14288 || temp_scroll_step
14289 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
))
14290 || NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
)))
14291 && CHARPOS (startp
) >= BEGV
14292 && CHARPOS (startp
) <= ZV
)
14294 /* The function returns -1 if new fonts were loaded, 1 if
14295 successful, 0 if not successful. */
14296 int ss
= try_scrolling (window
, just_this_one_p
,
14297 scroll_conservatively
,
14299 temp_scroll_step
, last_line_misfit
);
14302 case SCROLLING_SUCCESS
:
14305 case SCROLLING_NEED_LARGER_MATRICES
:
14306 goto need_larger_matrices
;
14308 case SCROLLING_FAILED
:
14316 /* Finally, just choose a place to start which positions point
14317 according to user preferences. */
14322 debug_method_add (w
, "recenter");
14325 /* w->vscroll = 0; */
14327 /* Forget any previously recorded base line for line number display. */
14328 if (!buffer_unchanged_p
)
14329 w
->base_line_number
= Qnil
;
14331 /* Determine the window start relative to point. */
14332 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
14333 it
.current_y
= it
.last_visible_y
;
14334 if (centering_position
< 0)
14338 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
14340 EMACS_INT margin_pos
= CHARPOS (startp
);
14342 Lisp_Object aggressive
;
14344 /* If there is a scroll margin at the top of the window, find
14345 its character position. */
14347 /* Cannot call start_display if startp is not in the
14348 accessible region of the buffer. This can happen when we
14349 have just switched to a different buffer and/or changed
14350 its restriction. In that case, startp is initialized to
14351 the character position 1 (BEG) because we did not yet
14352 have chance to display the buffer even once. */
14353 && BEGV
<= CHARPOS (startp
) && CHARPOS (startp
) <= ZV
)
14357 start_display (&it1
, w
, startp
);
14358 move_it_vertically (&it1
, margin
);
14359 margin_pos
= IT_CHARPOS (it1
);
14361 scrolling_up
= PT
> margin_pos
;
14364 ? BVAR (current_buffer
, scroll_up_aggressively
)
14365 : BVAR (current_buffer
, scroll_down_aggressively
);
14367 if (!MINI_WINDOW_P (w
)
14368 && (scroll_conservatively
> SCROLL_LIMIT
|| NUMBERP (aggressive
)))
14372 /* Setting scroll-conservatively overrides
14373 scroll-*-aggressively. */
14374 if (!scroll_conservatively
&& NUMBERP (aggressive
))
14376 double float_amount
= XFLOATINT (aggressive
);
14378 pt_offset
= float_amount
* WINDOW_BOX_TEXT_HEIGHT (w
);
14379 if (pt_offset
== 0 && float_amount
> 0)
14384 /* Compute how much to move the window start backward from
14385 point so that point will be displayed where the user
14389 centering_position
= it
.last_visible_y
;
14391 centering_position
-= pt_offset
;
14392 centering_position
-=
14393 FRAME_LINE_HEIGHT (f
) * (1 + margin
+ (last_line_misfit
!= 0));
14394 /* Don't let point enter the scroll margin near top of
14396 if (centering_position
< margin
* FRAME_LINE_HEIGHT (f
))
14397 centering_position
= margin
* FRAME_LINE_HEIGHT (f
);
14400 centering_position
= margin
* FRAME_LINE_HEIGHT (f
) + pt_offset
;
14403 /* Set the window start half the height of the window backward
14405 centering_position
= window_box_height (w
) / 2;
14407 move_it_vertically_backward (&it
, centering_position
);
14409 xassert (IT_CHARPOS (it
) >= BEGV
);
14411 /* The function move_it_vertically_backward may move over more
14412 than the specified y-distance. If it->w is small, e.g. a
14413 mini-buffer window, we may end up in front of the window's
14414 display area. Start displaying at the start of the line
14415 containing PT in this case. */
14416 if (it
.current_y
<= 0)
14418 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
14419 move_it_vertically_backward (&it
, 0);
14423 it
.current_x
= it
.hpos
= 0;
14425 /* Set the window start position here explicitly, to avoid an
14426 infinite loop in case the functions in window-scroll-functions
14428 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
14430 /* Run scroll hooks. */
14431 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
14433 /* Redisplay the window. */
14434 if (!current_matrix_up_to_date_p
14435 || windows_or_buffers_changed
14436 || cursor_type_changed
14437 /* Don't use try_window_reusing_current_matrix in this case
14438 because it can have changed the buffer. */
14439 || !NILP (Vwindow_scroll_functions
)
14440 || !just_this_one_p
14441 || MINI_WINDOW_P (w
)
14442 || !(used_current_matrix_p
14443 = try_window_reusing_current_matrix (w
)))
14444 try_window (window
, startp
, 0);
14446 /* If new fonts have been loaded (due to fontsets), give up. We
14447 have to start a new redisplay since we need to re-adjust glyph
14449 if (fonts_changed_p
)
14450 goto need_larger_matrices
;
14452 /* If cursor did not appear assume that the middle of the window is
14453 in the first line of the window. Do it again with the next line.
14454 (Imagine a window of height 100, displaying two lines of height
14455 60. Moving back 50 from it->last_visible_y will end in the first
14457 if (w
->cursor
.vpos
< 0)
14459 if (!NILP (w
->window_end_valid
)
14460 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
14462 clear_glyph_matrix (w
->desired_matrix
);
14463 move_it_by_lines (&it
, 1);
14464 try_window (window
, it
.current
.pos
, 0);
14466 else if (PT
< IT_CHARPOS (it
))
14468 clear_glyph_matrix (w
->desired_matrix
);
14469 move_it_by_lines (&it
, -1);
14470 try_window (window
, it
.current
.pos
, 0);
14474 /* Not much we can do about it. */
14478 /* Consider the following case: Window starts at BEGV, there is
14479 invisible, intangible text at BEGV, so that display starts at
14480 some point START > BEGV. It can happen that we are called with
14481 PT somewhere between BEGV and START. Try to handle that case. */
14482 if (w
->cursor
.vpos
< 0)
14484 struct glyph_row
*row
= w
->current_matrix
->rows
;
14485 if (row
->mode_line_p
)
14487 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
14490 if (!cursor_row_fully_visible_p (w
, 0, 0))
14492 /* If vscroll is enabled, disable it and try again. */
14496 clear_glyph_matrix (w
->desired_matrix
);
14500 /* If centering point failed to make the whole line visible,
14501 put point at the top instead. That has to make the whole line
14502 visible, if it can be done. */
14503 if (centering_position
== 0)
14506 clear_glyph_matrix (w
->desired_matrix
);
14507 centering_position
= 0;
14513 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14514 w
->start_at_line_beg
= ((CHARPOS (startp
) == BEGV
14515 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n')
14518 /* Display the mode line, if we must. */
14519 if ((update_mode_line
14520 /* If window not full width, must redo its mode line
14521 if (a) the window to its side is being redone and
14522 (b) we do a frame-based redisplay. This is a consequence
14523 of how inverted lines are drawn in frame-based redisplay. */
14524 || (!just_this_one_p
14525 && !FRAME_WINDOW_P (f
)
14526 && !WINDOW_FULL_WIDTH_P (w
))
14527 /* Line number to display. */
14528 || INTEGERP (w
->base_line_pos
)
14529 /* Column number is displayed and different from the one displayed. */
14530 || (!NILP (w
->column_number_displayed
)
14531 && (XFASTINT (w
->column_number_displayed
) != current_column ())))
14532 /* This means that the window has a mode line. */
14533 && (WINDOW_WANTS_MODELINE_P (w
)
14534 || WINDOW_WANTS_HEADER_LINE_P (w
)))
14536 display_mode_lines (w
);
14538 /* If mode line height has changed, arrange for a thorough
14539 immediate redisplay using the correct mode line height. */
14540 if (WINDOW_WANTS_MODELINE_P (w
)
14541 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
14543 fonts_changed_p
= 1;
14544 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
14545 = DESIRED_MODE_LINE_HEIGHT (w
);
14548 /* If header line height has changed, arrange for a thorough
14549 immediate redisplay using the correct header line height. */
14550 if (WINDOW_WANTS_HEADER_LINE_P (w
)
14551 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
14553 fonts_changed_p
= 1;
14554 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
14555 = DESIRED_HEADER_LINE_HEIGHT (w
);
14558 if (fonts_changed_p
)
14559 goto need_larger_matrices
;
14562 if (!line_number_displayed
14563 && !BUFFERP (w
->base_line_pos
))
14565 w
->base_line_pos
= Qnil
;
14566 w
->base_line_number
= Qnil
;
14571 /* When we reach a frame's selected window, redo the frame's menu bar. */
14572 if (update_mode_line
14573 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
14575 int redisplay_menu_p
= 0;
14577 if (FRAME_WINDOW_P (f
))
14579 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
14580 || defined (HAVE_NS) || defined (USE_GTK)
14581 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
14583 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
14587 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
14589 if (redisplay_menu_p
)
14590 display_menu_bar (w
);
14592 #ifdef HAVE_WINDOW_SYSTEM
14593 if (FRAME_WINDOW_P (f
))
14595 #if defined (USE_GTK) || defined (HAVE_NS)
14596 if (FRAME_EXTERNAL_TOOL_BAR (f
))
14597 redisplay_tool_bar (f
);
14599 if (WINDOWP (f
->tool_bar_window
)
14600 && (FRAME_TOOL_BAR_LINES (f
) > 0
14601 || !NILP (Vauto_resize_tool_bars
))
14602 && redisplay_tool_bar (f
))
14603 ignore_mouse_drag_p
= 1;
14609 #ifdef HAVE_WINDOW_SYSTEM
14610 if (FRAME_WINDOW_P (f
)
14611 && update_window_fringes (w
, (just_this_one_p
14612 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
14613 || w
->pseudo_window_p
)))
14617 if (draw_window_fringes (w
, 1))
14618 x_draw_vertical_border (w
);
14622 #endif /* HAVE_WINDOW_SYSTEM */
14624 /* We go to this label, with fonts_changed_p nonzero,
14625 if it is necessary to try again using larger glyph matrices.
14626 We have to redeem the scroll bar even in this case,
14627 because the loop in redisplay_internal expects that. */
14628 need_larger_matrices
:
14630 finish_scroll_bars
:
14632 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
14634 /* Set the thumb's position and size. */
14635 set_vertical_scroll_bar (w
);
14637 /* Note that we actually used the scroll bar attached to this
14638 window, so it shouldn't be deleted at the end of redisplay. */
14639 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
14640 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
14643 /* Restore current_buffer and value of point in it. The window
14644 update may have changed the buffer, so first make sure `opoint'
14645 is still valid (Bug#6177). */
14646 if (CHARPOS (opoint
) < BEGV
)
14647 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
14648 else if (CHARPOS (opoint
) > ZV
)
14649 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
14651 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
14653 set_buffer_internal_1 (old
);
14654 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
14655 shorter. This can be caused by log truncation in *Messages*. */
14656 if (CHARPOS (lpoint
) <= ZV
)
14657 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
14659 unbind_to (count
, Qnil
);
14663 /* Build the complete desired matrix of WINDOW with a window start
14664 buffer position POS.
14666 Value is 1 if successful. It is zero if fonts were loaded during
14667 redisplay which makes re-adjusting glyph matrices necessary, and -1
14668 if point would appear in the scroll margins.
14669 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
14670 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
14674 try_window (Lisp_Object window
, struct text_pos pos
, int flags
)
14676 struct window
*w
= XWINDOW (window
);
14678 struct glyph_row
*last_text_row
= NULL
;
14679 struct frame
*f
= XFRAME (w
->frame
);
14681 /* Make POS the new window start. */
14682 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
14684 /* Mark cursor position as unknown. No overlay arrow seen. */
14685 w
->cursor
.vpos
= -1;
14686 overlay_arrow_seen
= 0;
14688 /* Initialize iterator and info to start at POS. */
14689 start_display (&it
, w
, pos
);
14691 /* Display all lines of W. */
14692 while (it
.current_y
< it
.last_visible_y
)
14694 if (display_line (&it
))
14695 last_text_row
= it
.glyph_row
- 1;
14696 if (fonts_changed_p
&& !(flags
& TRY_WINDOW_IGNORE_FONTS_CHANGE
))
14700 /* Don't let the cursor end in the scroll margins. */
14701 if ((flags
& TRY_WINDOW_CHECK_MARGINS
)
14702 && !MINI_WINDOW_P (w
))
14704 int this_scroll_margin
;
14706 if (scroll_margin
> 0)
14708 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
14709 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
14712 this_scroll_margin
= 0;
14714 if ((w
->cursor
.y
>= 0 /* not vscrolled */
14715 && w
->cursor
.y
< this_scroll_margin
14716 && CHARPOS (pos
) > BEGV
14717 && IT_CHARPOS (it
) < ZV
)
14718 /* rms: considering make_cursor_line_fully_visible_p here
14719 seems to give wrong results. We don't want to recenter
14720 when the last line is partly visible, we want to allow
14721 that case to be handled in the usual way. */
14722 || w
->cursor
.y
> it
.last_visible_y
- this_scroll_margin
- 1)
14724 w
->cursor
.vpos
= -1;
14725 clear_glyph_matrix (w
->desired_matrix
);
14730 /* If bottom moved off end of frame, change mode line percentage. */
14731 if (XFASTINT (w
->window_end_pos
) <= 0
14732 && Z
!= IT_CHARPOS (it
))
14733 w
->update_mode_line
= Qt
;
14735 /* Set window_end_pos to the offset of the last character displayed
14736 on the window from the end of current_buffer. Set
14737 window_end_vpos to its row number. */
14740 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
14741 w
->window_end_bytepos
14742 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
14744 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
14746 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
14747 xassert (MATRIX_ROW (w
->desired_matrix
, XFASTINT (w
->window_end_vpos
))
14748 ->displays_text_p
);
14752 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
14753 w
->window_end_pos
= make_number (Z
- ZV
);
14754 w
->window_end_vpos
= make_number (0);
14757 /* But that is not valid info until redisplay finishes. */
14758 w
->window_end_valid
= Qnil
;
14764 /************************************************************************
14765 Window redisplay reusing current matrix when buffer has not changed
14766 ************************************************************************/
14768 /* Try redisplay of window W showing an unchanged buffer with a
14769 different window start than the last time it was displayed by
14770 reusing its current matrix. Value is non-zero if successful.
14771 W->start is the new window start. */
14774 try_window_reusing_current_matrix (struct window
*w
)
14776 struct frame
*f
= XFRAME (w
->frame
);
14777 struct glyph_row
*bottom_row
;
14780 struct text_pos start
, new_start
;
14781 int nrows_scrolled
, i
;
14782 struct glyph_row
*last_text_row
;
14783 struct glyph_row
*last_reused_text_row
;
14784 struct glyph_row
*start_row
;
14785 int start_vpos
, min_y
, max_y
;
14788 if (inhibit_try_window_reusing
)
14792 if (/* This function doesn't handle terminal frames. */
14793 !FRAME_WINDOW_P (f
)
14794 /* Don't try to reuse the display if windows have been split
14796 || windows_or_buffers_changed
14797 || cursor_type_changed
)
14800 /* Can't do this if region may have changed. */
14801 if ((!NILP (Vtransient_mark_mode
)
14802 && !NILP (BVAR (current_buffer
, mark_active
)))
14803 || !NILP (w
->region_showing
)
14804 || !NILP (Vshow_trailing_whitespace
))
14807 /* If top-line visibility has changed, give up. */
14808 if (WINDOW_WANTS_HEADER_LINE_P (w
)
14809 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
14812 /* Give up if old or new display is scrolled vertically. We could
14813 make this function handle this, but right now it doesn't. */
14814 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
14815 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
14818 /* The variable new_start now holds the new window start. The old
14819 start `start' can be determined from the current matrix. */
14820 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
14821 start
= start_row
->minpos
;
14822 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
14824 /* Clear the desired matrix for the display below. */
14825 clear_glyph_matrix (w
->desired_matrix
);
14827 if (CHARPOS (new_start
) <= CHARPOS (start
))
14829 /* Don't use this method if the display starts with an ellipsis
14830 displayed for invisible text. It's not easy to handle that case
14831 below, and it's certainly not worth the effort since this is
14832 not a frequent case. */
14833 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
14836 IF_DEBUG (debug_method_add (w
, "twu1"));
14838 /* Display up to a row that can be reused. The variable
14839 last_text_row is set to the last row displayed that displays
14840 text. Note that it.vpos == 0 if or if not there is a
14841 header-line; it's not the same as the MATRIX_ROW_VPOS! */
14842 start_display (&it
, w
, new_start
);
14843 w
->cursor
.vpos
= -1;
14844 last_text_row
= last_reused_text_row
= NULL
;
14846 while (it
.current_y
< it
.last_visible_y
14847 && !fonts_changed_p
)
14849 /* If we have reached into the characters in the START row,
14850 that means the line boundaries have changed. So we
14851 can't start copying with the row START. Maybe it will
14852 work to start copying with the following row. */
14853 while (IT_CHARPOS (it
) > CHARPOS (start
))
14855 /* Advance to the next row as the "start". */
14857 start
= start_row
->minpos
;
14858 /* If there are no more rows to try, or just one, give up. */
14859 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
14860 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
14861 || CHARPOS (start
) == ZV
)
14863 clear_glyph_matrix (w
->desired_matrix
);
14867 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
14869 /* If we have reached alignment,
14870 we can copy the rest of the rows. */
14871 if (IT_CHARPOS (it
) == CHARPOS (start
))
14874 if (display_line (&it
))
14875 last_text_row
= it
.glyph_row
- 1;
14878 /* A value of current_y < last_visible_y means that we stopped
14879 at the previous window start, which in turn means that we
14880 have at least one reusable row. */
14881 if (it
.current_y
< it
.last_visible_y
)
14883 struct glyph_row
*row
;
14885 /* IT.vpos always starts from 0; it counts text lines. */
14886 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
14888 /* Find PT if not already found in the lines displayed. */
14889 if (w
->cursor
.vpos
< 0)
14891 int dy
= it
.current_y
- start_row
->y
;
14893 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
14894 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
14896 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
14897 dy
, nrows_scrolled
);
14900 clear_glyph_matrix (w
->desired_matrix
);
14905 /* Scroll the display. Do it before the current matrix is
14906 changed. The problem here is that update has not yet
14907 run, i.e. part of the current matrix is not up to date.
14908 scroll_run_hook will clear the cursor, and use the
14909 current matrix to get the height of the row the cursor is
14911 run
.current_y
= start_row
->y
;
14912 run
.desired_y
= it
.current_y
;
14913 run
.height
= it
.last_visible_y
- it
.current_y
;
14915 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
14918 FRAME_RIF (f
)->update_window_begin_hook (w
);
14919 FRAME_RIF (f
)->clear_window_mouse_face (w
);
14920 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
14921 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
14925 /* Shift current matrix down by nrows_scrolled lines. */
14926 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
14927 rotate_matrix (w
->current_matrix
,
14929 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
14932 /* Disable lines that must be updated. */
14933 for (i
= 0; i
< nrows_scrolled
; ++i
)
14934 (start_row
+ i
)->enabled_p
= 0;
14936 /* Re-compute Y positions. */
14937 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
14938 max_y
= it
.last_visible_y
;
14939 for (row
= start_row
+ nrows_scrolled
;
14943 row
->y
= it
.current_y
;
14944 row
->visible_height
= row
->height
;
14946 if (row
->y
< min_y
)
14947 row
->visible_height
-= min_y
- row
->y
;
14948 if (row
->y
+ row
->height
> max_y
)
14949 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
14950 if (row
->fringe_bitmap_periodic_p
)
14951 row
->redraw_fringe_bitmaps_p
= 1;
14953 it
.current_y
+= row
->height
;
14955 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
14956 last_reused_text_row
= row
;
14957 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
14961 /* Disable lines in the current matrix which are now
14962 below the window. */
14963 for (++row
; row
< bottom_row
; ++row
)
14964 row
->enabled_p
= row
->mode_line_p
= 0;
14967 /* Update window_end_pos etc.; last_reused_text_row is the last
14968 reused row from the current matrix containing text, if any.
14969 The value of last_text_row is the last displayed line
14970 containing text. */
14971 if (last_reused_text_row
)
14973 w
->window_end_bytepos
14974 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
14976 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_reused_text_row
));
14978 = make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
14979 w
->current_matrix
));
14981 else if (last_text_row
)
14983 w
->window_end_bytepos
14984 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
14986 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
14988 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
14992 /* This window must be completely empty. */
14993 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
14994 w
->window_end_pos
= make_number (Z
- ZV
);
14995 w
->window_end_vpos
= make_number (0);
14997 w
->window_end_valid
= Qnil
;
14999 /* Update hint: don't try scrolling again in update_window. */
15000 w
->desired_matrix
->no_scrolling_p
= 1;
15003 debug_method_add (w
, "try_window_reusing_current_matrix 1");
15007 else if (CHARPOS (new_start
) > CHARPOS (start
))
15009 struct glyph_row
*pt_row
, *row
;
15010 struct glyph_row
*first_reusable_row
;
15011 struct glyph_row
*first_row_to_display
;
15013 int yb
= window_text_bottom_y (w
);
15015 /* Find the row starting at new_start, if there is one. Don't
15016 reuse a partially visible line at the end. */
15017 first_reusable_row
= start_row
;
15018 while (first_reusable_row
->enabled_p
15019 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
15020 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
15021 < CHARPOS (new_start
)))
15022 ++first_reusable_row
;
15024 /* Give up if there is no row to reuse. */
15025 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
15026 || !first_reusable_row
->enabled_p
15027 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
15028 != CHARPOS (new_start
)))
15031 /* We can reuse fully visible rows beginning with
15032 first_reusable_row to the end of the window. Set
15033 first_row_to_display to the first row that cannot be reused.
15034 Set pt_row to the row containing point, if there is any. */
15036 for (first_row_to_display
= first_reusable_row
;
15037 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
15038 ++first_row_to_display
)
15040 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
15041 && PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
))
15042 pt_row
= first_row_to_display
;
15045 /* Start displaying at the start of first_row_to_display. */
15046 xassert (first_row_to_display
->y
< yb
);
15047 init_to_row_start (&it
, w
, first_row_to_display
);
15049 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
15051 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
15053 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
15054 + WINDOW_HEADER_LINE_HEIGHT (w
));
15056 /* Display lines beginning with first_row_to_display in the
15057 desired matrix. Set last_text_row to the last row displayed
15058 that displays text. */
15059 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
15060 if (pt_row
== NULL
)
15061 w
->cursor
.vpos
= -1;
15062 last_text_row
= NULL
;
15063 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
15064 if (display_line (&it
))
15065 last_text_row
= it
.glyph_row
- 1;
15067 /* If point is in a reused row, adjust y and vpos of the cursor
15071 w
->cursor
.vpos
-= nrows_scrolled
;
15072 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
15075 /* Give up if point isn't in a row displayed or reused. (This
15076 also handles the case where w->cursor.vpos < nrows_scrolled
15077 after the calls to display_line, which can happen with scroll
15078 margins. See bug#1295.) */
15079 if (w
->cursor
.vpos
< 0)
15081 clear_glyph_matrix (w
->desired_matrix
);
15085 /* Scroll the display. */
15086 run
.current_y
= first_reusable_row
->y
;
15087 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
15088 run
.height
= it
.last_visible_y
- run
.current_y
;
15089 dy
= run
.current_y
- run
.desired_y
;
15094 FRAME_RIF (f
)->update_window_begin_hook (w
);
15095 FRAME_RIF (f
)->clear_window_mouse_face (w
);
15096 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
15097 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
15101 /* Adjust Y positions of reused rows. */
15102 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
15103 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
15104 max_y
= it
.last_visible_y
;
15105 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
15108 row
->visible_height
= row
->height
;
15109 if (row
->y
< min_y
)
15110 row
->visible_height
-= min_y
- row
->y
;
15111 if (row
->y
+ row
->height
> max_y
)
15112 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
15113 if (row
->fringe_bitmap_periodic_p
)
15114 row
->redraw_fringe_bitmaps_p
= 1;
15117 /* Scroll the current matrix. */
15118 xassert (nrows_scrolled
> 0);
15119 rotate_matrix (w
->current_matrix
,
15121 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
15124 /* Disable rows not reused. */
15125 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
15126 row
->enabled_p
= 0;
15128 /* Point may have moved to a different line, so we cannot assume that
15129 the previous cursor position is valid; locate the correct row. */
15132 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
15133 row
< bottom_row
&& PT
>= MATRIX_ROW_END_CHARPOS (row
);
15137 w
->cursor
.y
= row
->y
;
15139 if (row
< bottom_row
)
15141 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
15142 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
15144 /* Can't use this optimization with bidi-reordered glyph
15145 rows, unless cursor is already at point. */
15146 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15148 if (!(w
->cursor
.hpos
>= 0
15149 && w
->cursor
.hpos
< row
->used
[TEXT_AREA
]
15150 && BUFFERP (glyph
->object
)
15151 && glyph
->charpos
== PT
))
15156 && (!BUFFERP (glyph
->object
)
15157 || glyph
->charpos
< PT
);
15161 w
->cursor
.x
+= glyph
->pixel_width
;
15166 /* Adjust window end. A null value of last_text_row means that
15167 the window end is in reused rows which in turn means that
15168 only its vpos can have changed. */
15171 w
->window_end_bytepos
15172 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
15174 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
15176 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
15181 = make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
);
15184 w
->window_end_valid
= Qnil
;
15185 w
->desired_matrix
->no_scrolling_p
= 1;
15188 debug_method_add (w
, "try_window_reusing_current_matrix 2");
15198 /************************************************************************
15199 Window redisplay reusing current matrix when buffer has changed
15200 ************************************************************************/
15202 static struct glyph_row
*find_last_unchanged_at_beg_row (struct window
*);
15203 static struct glyph_row
*find_first_unchanged_at_end_row (struct window
*,
15204 EMACS_INT
*, EMACS_INT
*);
15205 static struct glyph_row
*
15206 find_last_row_displaying_text (struct glyph_matrix
*, struct it
*,
15207 struct glyph_row
*);
15210 /* Return the last row in MATRIX displaying text. If row START is
15211 non-null, start searching with that row. IT gives the dimensions
15212 of the display. Value is null if matrix is empty; otherwise it is
15213 a pointer to the row found. */
15215 static struct glyph_row
*
15216 find_last_row_displaying_text (struct glyph_matrix
*matrix
, struct it
*it
,
15217 struct glyph_row
*start
)
15219 struct glyph_row
*row
, *row_found
;
15221 /* Set row_found to the last row in IT->w's current matrix
15222 displaying text. The loop looks funny but think of partially
15225 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
15226 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
15228 xassert (row
->enabled_p
);
15230 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
15239 /* Return the last row in the current matrix of W that is not affected
15240 by changes at the start of current_buffer that occurred since W's
15241 current matrix was built. Value is null if no such row exists.
15243 BEG_UNCHANGED us the number of characters unchanged at the start of
15244 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
15245 first changed character in current_buffer. Characters at positions <
15246 BEG + BEG_UNCHANGED are at the same buffer positions as they were
15247 when the current matrix was built. */
15249 static struct glyph_row
*
15250 find_last_unchanged_at_beg_row (struct window
*w
)
15252 EMACS_INT first_changed_pos
= BEG
+ BEG_UNCHANGED
;
15253 struct glyph_row
*row
;
15254 struct glyph_row
*row_found
= NULL
;
15255 int yb
= window_text_bottom_y (w
);
15257 /* Find the last row displaying unchanged text. */
15258 for (row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15259 MATRIX_ROW_DISPLAYS_TEXT_P (row
)
15260 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
;
15263 if (/* If row ends before first_changed_pos, it is unchanged,
15264 except in some case. */
15265 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
15266 /* When row ends in ZV and we write at ZV it is not
15268 && !row
->ends_at_zv_p
15269 /* When first_changed_pos is the end of a continued line,
15270 row is not unchanged because it may be no longer
15272 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
15273 && (row
->continued_p
15274 || row
->exact_window_width_line_p
)))
15277 /* Stop if last visible row. */
15278 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
15286 /* Find the first glyph row in the current matrix of W that is not
15287 affected by changes at the end of current_buffer since the
15288 time W's current matrix was built.
15290 Return in *DELTA the number of chars by which buffer positions in
15291 unchanged text at the end of current_buffer must be adjusted.
15293 Return in *DELTA_BYTES the corresponding number of bytes.
15295 Value is null if no such row exists, i.e. all rows are affected by
15298 static struct glyph_row
*
15299 find_first_unchanged_at_end_row (struct window
*w
,
15300 EMACS_INT
*delta
, EMACS_INT
*delta_bytes
)
15302 struct glyph_row
*row
;
15303 struct glyph_row
*row_found
= NULL
;
15305 *delta
= *delta_bytes
= 0;
15307 /* Display must not have been paused, otherwise the current matrix
15308 is not up to date. */
15309 eassert (!NILP (w
->window_end_valid
));
15311 /* A value of window_end_pos >= END_UNCHANGED means that the window
15312 end is in the range of changed text. If so, there is no
15313 unchanged row at the end of W's current matrix. */
15314 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
15317 /* Set row to the last row in W's current matrix displaying text. */
15318 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
15320 /* If matrix is entirely empty, no unchanged row exists. */
15321 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
15323 /* The value of row is the last glyph row in the matrix having a
15324 meaningful buffer position in it. The end position of row
15325 corresponds to window_end_pos. This allows us to translate
15326 buffer positions in the current matrix to current buffer
15327 positions for characters not in changed text. */
15329 MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
15330 EMACS_INT Z_BYTE_old
=
15331 MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
15332 EMACS_INT last_unchanged_pos
, last_unchanged_pos_old
;
15333 struct glyph_row
*first_text_row
15334 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15336 *delta
= Z
- Z_old
;
15337 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
15339 /* Set last_unchanged_pos to the buffer position of the last
15340 character in the buffer that has not been changed. Z is the
15341 index + 1 of the last character in current_buffer, i.e. by
15342 subtracting END_UNCHANGED we get the index of the last
15343 unchanged character, and we have to add BEG to get its buffer
15345 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
15346 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
15348 /* Search backward from ROW for a row displaying a line that
15349 starts at a minimum position >= last_unchanged_pos_old. */
15350 for (; row
> first_text_row
; --row
)
15352 /* This used to abort, but it can happen.
15353 It is ok to just stop the search instead here. KFS. */
15354 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
15357 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
15362 eassert (!row_found
|| MATRIX_ROW_DISPLAYS_TEXT_P (row_found
));
15368 /* Make sure that glyph rows in the current matrix of window W
15369 reference the same glyph memory as corresponding rows in the
15370 frame's frame matrix. This function is called after scrolling W's
15371 current matrix on a terminal frame in try_window_id and
15372 try_window_reusing_current_matrix. */
15375 sync_frame_with_window_matrix_rows (struct window
*w
)
15377 struct frame
*f
= XFRAME (w
->frame
);
15378 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
15380 /* Preconditions: W must be a leaf window and full-width. Its frame
15381 must have a frame matrix. */
15382 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
15383 xassert (WINDOW_FULL_WIDTH_P (w
));
15384 xassert (!FRAME_WINDOW_P (f
));
15386 /* If W is a full-width window, glyph pointers in W's current matrix
15387 have, by definition, to be the same as glyph pointers in the
15388 corresponding frame matrix. Note that frame matrices have no
15389 marginal areas (see build_frame_matrix). */
15390 window_row
= w
->current_matrix
->rows
;
15391 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
15392 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
15393 while (window_row
< window_row_end
)
15395 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
15396 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
15398 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
15399 frame_row
->glyphs
[TEXT_AREA
] = start
;
15400 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
15401 frame_row
->glyphs
[LAST_AREA
] = end
;
15403 /* Disable frame rows whose corresponding window rows have
15404 been disabled in try_window_id. */
15405 if (!window_row
->enabled_p
)
15406 frame_row
->enabled_p
= 0;
15408 ++window_row
, ++frame_row
;
15413 /* Find the glyph row in window W containing CHARPOS. Consider all
15414 rows between START and END (not inclusive). END null means search
15415 all rows to the end of the display area of W. Value is the row
15416 containing CHARPOS or null. */
15419 row_containing_pos (struct window
*w
, EMACS_INT charpos
,
15420 struct glyph_row
*start
, struct glyph_row
*end
, int dy
)
15422 struct glyph_row
*row
= start
;
15423 struct glyph_row
*best_row
= NULL
;
15424 EMACS_INT mindif
= BUF_ZV (XBUFFER (w
->buffer
)) + 1;
15427 /* If we happen to start on a header-line, skip that. */
15428 if (row
->mode_line_p
)
15431 if ((end
&& row
>= end
) || !row
->enabled_p
)
15434 last_y
= window_text_bottom_y (w
) - dy
;
15438 /* Give up if we have gone too far. */
15439 if (end
&& row
>= end
)
15441 /* This formerly returned if they were equal.
15442 I think that both quantities are of a "last plus one" type;
15443 if so, when they are equal, the row is within the screen. -- rms. */
15444 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
15447 /* If it is in this row, return this row. */
15448 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
15449 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
15450 /* The end position of a row equals the start
15451 position of the next row. If CHARPOS is there, we
15452 would rather display it in the next line, except
15453 when this line ends in ZV. */
15454 && !row
->ends_at_zv_p
15455 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
15456 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
15460 if (NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
15461 || (!best_row
&& !row
->continued_p
))
15463 /* In bidi-reordered rows, there could be several rows
15464 occluding point, all of them belonging to the same
15465 continued line. We need to find the row which fits
15466 CHARPOS the best. */
15467 for (g
= row
->glyphs
[TEXT_AREA
];
15468 g
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
15471 if (!STRINGP (g
->object
))
15473 if (g
->charpos
> 0 && eabs (g
->charpos
- charpos
) < mindif
)
15475 mindif
= eabs (g
->charpos
- charpos
);
15477 /* Exact match always wins. */
15484 else if (best_row
&& !row
->continued_p
)
15491 /* Try to redisplay window W by reusing its existing display. W's
15492 current matrix must be up to date when this function is called,
15493 i.e. window_end_valid must not be nil.
15497 1 if display has been updated
15498 0 if otherwise unsuccessful
15499 -1 if redisplay with same window start is known not to succeed
15501 The following steps are performed:
15503 1. Find the last row in the current matrix of W that is not
15504 affected by changes at the start of current_buffer. If no such row
15507 2. Find the first row in W's current matrix that is not affected by
15508 changes at the end of current_buffer. Maybe there is no such row.
15510 3. Display lines beginning with the row + 1 found in step 1 to the
15511 row found in step 2 or, if step 2 didn't find a row, to the end of
15514 4. If cursor is not known to appear on the window, give up.
15516 5. If display stopped at the row found in step 2, scroll the
15517 display and current matrix as needed.
15519 6. Maybe display some lines at the end of W, if we must. This can
15520 happen under various circumstances, like a partially visible line
15521 becoming fully visible, or because newly displayed lines are displayed
15522 in smaller font sizes.
15524 7. Update W's window end information. */
15527 try_window_id (struct window
*w
)
15529 struct frame
*f
= XFRAME (w
->frame
);
15530 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
15531 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
15532 struct glyph_row
*last_unchanged_at_beg_row
;
15533 struct glyph_row
*first_unchanged_at_end_row
;
15534 struct glyph_row
*row
;
15535 struct glyph_row
*bottom_row
;
15538 EMACS_INT delta
= 0, delta_bytes
= 0, stop_pos
;
15540 struct text_pos start_pos
;
15542 int first_unchanged_at_end_vpos
= 0;
15543 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
15544 struct text_pos start
;
15545 EMACS_INT first_changed_charpos
, last_changed_charpos
;
15548 if (inhibit_try_window_id
)
15552 /* This is handy for debugging. */
15554 #define GIVE_UP(X) \
15556 fprintf (stderr, "try_window_id give up %d\n", (X)); \
15560 #define GIVE_UP(X) return 0
15563 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
15565 /* Don't use this for mini-windows because these can show
15566 messages and mini-buffers, and we don't handle that here. */
15567 if (MINI_WINDOW_P (w
))
15570 /* This flag is used to prevent redisplay optimizations. */
15571 if (windows_or_buffers_changed
|| cursor_type_changed
)
15574 /* Verify that narrowing has not changed.
15575 Also verify that we were not told to prevent redisplay optimizations.
15576 It would be nice to further
15577 reduce the number of cases where this prevents try_window_id. */
15578 if (current_buffer
->clip_changed
15579 || current_buffer
->prevent_redisplay_optimizations_p
)
15582 /* Window must either use window-based redisplay or be full width. */
15583 if (!FRAME_WINDOW_P (f
)
15584 && (!FRAME_LINE_INS_DEL_OK (f
)
15585 || !WINDOW_FULL_WIDTH_P (w
)))
15588 /* Give up if point is known NOT to appear in W. */
15589 if (PT
< CHARPOS (start
))
15592 /* Another way to prevent redisplay optimizations. */
15593 if (XFASTINT (w
->last_modified
) == 0)
15596 /* Verify that window is not hscrolled. */
15597 if (XFASTINT (w
->hscroll
) != 0)
15600 /* Verify that display wasn't paused. */
15601 if (NILP (w
->window_end_valid
))
15604 /* Can't use this if highlighting a region because a cursor movement
15605 will do more than just set the cursor. */
15606 if (!NILP (Vtransient_mark_mode
)
15607 && !NILP (BVAR (current_buffer
, mark_active
)))
15610 /* Likewise if highlighting trailing whitespace. */
15611 if (!NILP (Vshow_trailing_whitespace
))
15614 /* Likewise if showing a region. */
15615 if (!NILP (w
->region_showing
))
15618 /* Can't use this if overlay arrow position and/or string have
15620 if (overlay_arrows_changed_p ())
15623 /* When word-wrap is on, adding a space to the first word of a
15624 wrapped line can change the wrap position, altering the line
15625 above it. It might be worthwhile to handle this more
15626 intelligently, but for now just redisplay from scratch. */
15627 if (!NILP (BVAR (XBUFFER (w
->buffer
), word_wrap
)))
15630 /* Under bidi reordering, adding or deleting a character in the
15631 beginning of a paragraph, before the first strong directional
15632 character, can change the base direction of the paragraph (unless
15633 the buffer specifies a fixed paragraph direction), which will
15634 require to redisplay the whole paragraph. It might be worthwhile
15635 to find the paragraph limits and widen the range of redisplayed
15636 lines to that, but for now just give up this optimization and
15637 redisplay from scratch. */
15638 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
15639 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
15642 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
15643 only if buffer has really changed. The reason is that the gap is
15644 initially at Z for freshly visited files. The code below would
15645 set end_unchanged to 0 in that case. */
15646 if (MODIFF
> SAVE_MODIFF
15647 /* This seems to happen sometimes after saving a buffer. */
15648 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
15650 if (GPT
- BEG
< BEG_UNCHANGED
)
15651 BEG_UNCHANGED
= GPT
- BEG
;
15652 if (Z
- GPT
< END_UNCHANGED
)
15653 END_UNCHANGED
= Z
- GPT
;
15656 /* The position of the first and last character that has been changed. */
15657 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
15658 last_changed_charpos
= Z
- END_UNCHANGED
;
15660 /* If window starts after a line end, and the last change is in
15661 front of that newline, then changes don't affect the display.
15662 This case happens with stealth-fontification. Note that although
15663 the display is unchanged, glyph positions in the matrix have to
15664 be adjusted, of course. */
15665 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
15666 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
15667 && ((last_changed_charpos
< CHARPOS (start
)
15668 && CHARPOS (start
) == BEGV
)
15669 || (last_changed_charpos
< CHARPOS (start
) - 1
15670 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
15672 EMACS_INT Z_old
, Z_delta
, Z_BYTE_old
, Z_delta_bytes
;
15673 struct glyph_row
*r0
;
15675 /* Compute how many chars/bytes have been added to or removed
15676 from the buffer. */
15677 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
15678 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
15679 Z_delta
= Z
- Z_old
;
15680 Z_delta_bytes
= Z_BYTE
- Z_BYTE_old
;
15682 /* Give up if PT is not in the window. Note that it already has
15683 been checked at the start of try_window_id that PT is not in
15684 front of the window start. */
15685 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + Z_delta
)
15688 /* If window start is unchanged, we can reuse the whole matrix
15689 as is, after adjusting glyph positions. No need to compute
15690 the window end again, since its offset from Z hasn't changed. */
15691 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
15692 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + Z_delta
15693 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + Z_delta_bytes
15694 /* PT must not be in a partially visible line. */
15695 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + Z_delta
15696 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
15698 /* Adjust positions in the glyph matrix. */
15699 if (Z_delta
|| Z_delta_bytes
)
15701 struct glyph_row
*r1
15702 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
15703 increment_matrix_positions (w
->current_matrix
,
15704 MATRIX_ROW_VPOS (r0
, current_matrix
),
15705 MATRIX_ROW_VPOS (r1
, current_matrix
),
15706 Z_delta
, Z_delta_bytes
);
15709 /* Set the cursor. */
15710 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
15712 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
15719 /* Handle the case that changes are all below what is displayed in
15720 the window, and that PT is in the window. This shortcut cannot
15721 be taken if ZV is visible in the window, and text has been added
15722 there that is visible in the window. */
15723 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
15724 /* ZV is not visible in the window, or there are no
15725 changes at ZV, actually. */
15726 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
15727 || first_changed_charpos
== last_changed_charpos
))
15729 struct glyph_row
*r0
;
15731 /* Give up if PT is not in the window. Note that it already has
15732 been checked at the start of try_window_id that PT is not in
15733 front of the window start. */
15734 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
15737 /* If window start is unchanged, we can reuse the whole matrix
15738 as is, without changing glyph positions since no text has
15739 been added/removed in front of the window end. */
15740 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
15741 if (TEXT_POS_EQUAL_P (start
, r0
->minpos
)
15742 /* PT must not be in a partially visible line. */
15743 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
15744 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
15746 /* We have to compute the window end anew since text
15747 could have been added/removed after it. */
15749 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
15750 w
->window_end_bytepos
15751 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
15753 /* Set the cursor. */
15754 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
15756 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
15763 /* Give up if window start is in the changed area.
15765 The condition used to read
15767 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
15769 but why that was tested escapes me at the moment. */
15770 if (CHARPOS (start
) >= first_changed_charpos
15771 && CHARPOS (start
) <= last_changed_charpos
)
15774 /* Check that window start agrees with the start of the first glyph
15775 row in its current matrix. Check this after we know the window
15776 start is not in changed text, otherwise positions would not be
15778 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
15779 if (!TEXT_POS_EQUAL_P (start
, row
->minpos
))
15782 /* Give up if the window ends in strings. Overlay strings
15783 at the end are difficult to handle, so don't try. */
15784 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
15785 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
15788 /* Compute the position at which we have to start displaying new
15789 lines. Some of the lines at the top of the window might be
15790 reusable because they are not displaying changed text. Find the
15791 last row in W's current matrix not affected by changes at the
15792 start of current_buffer. Value is null if changes start in the
15793 first line of window. */
15794 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
15795 if (last_unchanged_at_beg_row
)
15797 /* Avoid starting to display in the moddle of a character, a TAB
15798 for instance. This is easier than to set up the iterator
15799 exactly, and it's not a frequent case, so the additional
15800 effort wouldn't really pay off. */
15801 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
15802 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
15803 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
15804 --last_unchanged_at_beg_row
;
15806 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
15809 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
15811 start_pos
= it
.current
.pos
;
15813 /* Start displaying new lines in the desired matrix at the same
15814 vpos we would use in the current matrix, i.e. below
15815 last_unchanged_at_beg_row. */
15816 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
15818 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
15819 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
15821 xassert (it
.hpos
== 0 && it
.current_x
== 0);
15825 /* There are no reusable lines at the start of the window.
15826 Start displaying in the first text line. */
15827 start_display (&it
, w
, start
);
15828 it
.vpos
= it
.first_vpos
;
15829 start_pos
= it
.current
.pos
;
15832 /* Find the first row that is not affected by changes at the end of
15833 the buffer. Value will be null if there is no unchanged row, in
15834 which case we must redisplay to the end of the window. delta
15835 will be set to the value by which buffer positions beginning with
15836 first_unchanged_at_end_row have to be adjusted due to text
15838 first_unchanged_at_end_row
15839 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
15840 IF_DEBUG (debug_delta
= delta
);
15841 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
15843 /* Set stop_pos to the buffer position up to which we will have to
15844 display new lines. If first_unchanged_at_end_row != NULL, this
15845 is the buffer position of the start of the line displayed in that
15846 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
15847 that we don't stop at a buffer position. */
15849 if (first_unchanged_at_end_row
)
15851 xassert (last_unchanged_at_beg_row
== NULL
15852 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
15854 /* If this is a continuation line, move forward to the next one
15855 that isn't. Changes in lines above affect this line.
15856 Caution: this may move first_unchanged_at_end_row to a row
15857 not displaying text. */
15858 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
15859 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
15860 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
15861 < it
.last_visible_y
))
15862 ++first_unchanged_at_end_row
;
15864 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
15865 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
15866 >= it
.last_visible_y
))
15867 first_unchanged_at_end_row
= NULL
;
15870 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
15872 first_unchanged_at_end_vpos
15873 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
15874 xassert (stop_pos
>= Z
- END_UNCHANGED
);
15877 else if (last_unchanged_at_beg_row
== NULL
)
15883 /* Either there is no unchanged row at the end, or the one we have
15884 now displays text. This is a necessary condition for the window
15885 end pos calculation at the end of this function. */
15886 xassert (first_unchanged_at_end_row
== NULL
15887 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
15889 debug_last_unchanged_at_beg_vpos
15890 = (last_unchanged_at_beg_row
15891 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
15893 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
15895 #endif /* GLYPH_DEBUG != 0 */
15898 /* Display new lines. Set last_text_row to the last new line
15899 displayed which has text on it, i.e. might end up as being the
15900 line where the window_end_vpos is. */
15901 w
->cursor
.vpos
= -1;
15902 last_text_row
= NULL
;
15903 overlay_arrow_seen
= 0;
15904 while (it
.current_y
< it
.last_visible_y
15905 && !fonts_changed_p
15906 && (first_unchanged_at_end_row
== NULL
15907 || IT_CHARPOS (it
) < stop_pos
))
15909 if (display_line (&it
))
15910 last_text_row
= it
.glyph_row
- 1;
15913 if (fonts_changed_p
)
15917 /* Compute differences in buffer positions, y-positions etc. for
15918 lines reused at the bottom of the window. Compute what we can
15920 if (first_unchanged_at_end_row
15921 /* No lines reused because we displayed everything up to the
15922 bottom of the window. */
15923 && it
.current_y
< it
.last_visible_y
)
15926 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
15928 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
15929 run
.current_y
= first_unchanged_at_end_row
->y
;
15930 run
.desired_y
= run
.current_y
+ dy
;
15931 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
15935 delta
= delta_bytes
= dvpos
= dy
15936 = run
.current_y
= run
.desired_y
= run
.height
= 0;
15937 first_unchanged_at_end_row
= NULL
;
15939 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
15942 /* Find the cursor if not already found. We have to decide whether
15943 PT will appear on this window (it sometimes doesn't, but this is
15944 not a very frequent case.) This decision has to be made before
15945 the current matrix is altered. A value of cursor.vpos < 0 means
15946 that PT is either in one of the lines beginning at
15947 first_unchanged_at_end_row or below the window. Don't care for
15948 lines that might be displayed later at the window end; as
15949 mentioned, this is not a frequent case. */
15950 if (w
->cursor
.vpos
< 0)
15952 /* Cursor in unchanged rows at the top? */
15953 if (PT
< CHARPOS (start_pos
)
15954 && last_unchanged_at_beg_row
)
15956 row
= row_containing_pos (w
, PT
,
15957 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
15958 last_unchanged_at_beg_row
+ 1, 0);
15960 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15963 /* Start from first_unchanged_at_end_row looking for PT. */
15964 else if (first_unchanged_at_end_row
)
15966 row
= row_containing_pos (w
, PT
- delta
,
15967 first_unchanged_at_end_row
, NULL
, 0);
15969 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
15970 delta_bytes
, dy
, dvpos
);
15973 /* Give up if cursor was not found. */
15974 if (w
->cursor
.vpos
< 0)
15976 clear_glyph_matrix (w
->desired_matrix
);
15981 /* Don't let the cursor end in the scroll margins. */
15983 int this_scroll_margin
, cursor_height
;
15985 this_scroll_margin
= max (0, scroll_margin
);
15986 this_scroll_margin
= min (this_scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15987 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
15988 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
15990 if ((w
->cursor
.y
< this_scroll_margin
15991 && CHARPOS (start
) > BEGV
)
15992 /* Old redisplay didn't take scroll margin into account at the bottom,
15993 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
15994 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
15995 ? cursor_height
+ this_scroll_margin
15996 : 1)) > it
.last_visible_y
)
15998 w
->cursor
.vpos
= -1;
15999 clear_glyph_matrix (w
->desired_matrix
);
16004 /* Scroll the display. Do it before changing the current matrix so
16005 that xterm.c doesn't get confused about where the cursor glyph is
16007 if (dy
&& run
.height
)
16011 if (FRAME_WINDOW_P (f
))
16013 FRAME_RIF (f
)->update_window_begin_hook (w
);
16014 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16015 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16016 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16020 /* Terminal frame. In this case, dvpos gives the number of
16021 lines to scroll by; dvpos < 0 means scroll up. */
16023 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
16024 int from
= WINDOW_TOP_EDGE_LINE (w
) + from_vpos
;
16025 int end
= (WINDOW_TOP_EDGE_LINE (w
)
16026 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
16027 + window_internal_height (w
));
16029 #if defined (HAVE_GPM) || defined (MSDOS)
16030 x_clear_window_mouse_face (w
);
16032 /* Perform the operation on the screen. */
16035 /* Scroll last_unchanged_at_beg_row to the end of the
16036 window down dvpos lines. */
16037 set_terminal_window (f
, end
);
16039 /* On dumb terminals delete dvpos lines at the end
16040 before inserting dvpos empty lines. */
16041 if (!FRAME_SCROLL_REGION_OK (f
))
16042 ins_del_lines (f
, end
- dvpos
, -dvpos
);
16044 /* Insert dvpos empty lines in front of
16045 last_unchanged_at_beg_row. */
16046 ins_del_lines (f
, from
, dvpos
);
16048 else if (dvpos
< 0)
16050 /* Scroll up last_unchanged_at_beg_vpos to the end of
16051 the window to last_unchanged_at_beg_vpos - |dvpos|. */
16052 set_terminal_window (f
, end
);
16054 /* Delete dvpos lines in front of
16055 last_unchanged_at_beg_vpos. ins_del_lines will set
16056 the cursor to the given vpos and emit |dvpos| delete
16058 ins_del_lines (f
, from
+ dvpos
, dvpos
);
16060 /* On a dumb terminal insert dvpos empty lines at the
16062 if (!FRAME_SCROLL_REGION_OK (f
))
16063 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
16066 set_terminal_window (f
, 0);
16072 /* Shift reused rows of the current matrix to the right position.
16073 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
16075 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
16076 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
16079 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
16080 bottom_vpos
, dvpos
);
16081 enable_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
16084 else if (dvpos
> 0)
16086 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
16087 bottom_vpos
, dvpos
);
16088 enable_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
16089 first_unchanged_at_end_vpos
+ dvpos
, 0);
16092 /* For frame-based redisplay, make sure that current frame and window
16093 matrix are in sync with respect to glyph memory. */
16094 if (!FRAME_WINDOW_P (f
))
16095 sync_frame_with_window_matrix_rows (w
);
16097 /* Adjust buffer positions in reused rows. */
16098 if (delta
|| delta_bytes
)
16099 increment_matrix_positions (current_matrix
,
16100 first_unchanged_at_end_vpos
+ dvpos
,
16101 bottom_vpos
, delta
, delta_bytes
);
16103 /* Adjust Y positions. */
16105 shift_glyph_matrix (w
, current_matrix
,
16106 first_unchanged_at_end_vpos
+ dvpos
,
16109 if (first_unchanged_at_end_row
)
16111 first_unchanged_at_end_row
+= dvpos
;
16112 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
16113 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
16114 first_unchanged_at_end_row
= NULL
;
16117 /* If scrolling up, there may be some lines to display at the end of
16119 last_text_row_at_end
= NULL
;
16122 /* Scrolling up can leave for example a partially visible line
16123 at the end of the window to be redisplayed. */
16124 /* Set last_row to the glyph row in the current matrix where the
16125 window end line is found. It has been moved up or down in
16126 the matrix by dvpos. */
16127 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
16128 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
16130 /* If last_row is the window end line, it should display text. */
16131 xassert (last_row
->displays_text_p
);
16133 /* If window end line was partially visible before, begin
16134 displaying at that line. Otherwise begin displaying with the
16135 line following it. */
16136 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
16138 init_to_row_start (&it
, w
, last_row
);
16139 it
.vpos
= last_vpos
;
16140 it
.current_y
= last_row
->y
;
16144 init_to_row_end (&it
, w
, last_row
);
16145 it
.vpos
= 1 + last_vpos
;
16146 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
16150 /* We may start in a continuation line. If so, we have to
16151 get the right continuation_lines_width and current_x. */
16152 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
16153 it
.hpos
= it
.current_x
= 0;
16155 /* Display the rest of the lines at the window end. */
16156 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
16157 while (it
.current_y
< it
.last_visible_y
16158 && !fonts_changed_p
)
16160 /* Is it always sure that the display agrees with lines in
16161 the current matrix? I don't think so, so we mark rows
16162 displayed invalid in the current matrix by setting their
16163 enabled_p flag to zero. */
16164 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
16165 if (display_line (&it
))
16166 last_text_row_at_end
= it
.glyph_row
- 1;
16170 /* Update window_end_pos and window_end_vpos. */
16171 if (first_unchanged_at_end_row
16172 && !last_text_row_at_end
)
16174 /* Window end line if one of the preserved rows from the current
16175 matrix. Set row to the last row displaying text in current
16176 matrix starting at first_unchanged_at_end_row, after
16178 xassert (first_unchanged_at_end_row
->displays_text_p
);
16179 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
16180 first_unchanged_at_end_row
);
16181 xassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
16183 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
16184 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
16186 = make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
));
16187 xassert (w
->window_end_bytepos
>= 0);
16188 IF_DEBUG (debug_method_add (w
, "A"));
16190 else if (last_text_row_at_end
)
16193 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
));
16194 w
->window_end_bytepos
16195 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
16197 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end
, desired_matrix
));
16198 xassert (w
->window_end_bytepos
>= 0);
16199 IF_DEBUG (debug_method_add (w
, "B"));
16201 else if (last_text_row
)
16203 /* We have displayed either to the end of the window or at the
16204 end of the window, i.e. the last row with text is to be found
16205 in the desired matrix. */
16207 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
16208 w
->window_end_bytepos
16209 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16211 = make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
));
16212 xassert (w
->window_end_bytepos
>= 0);
16214 else if (first_unchanged_at_end_row
== NULL
16215 && last_text_row
== NULL
16216 && last_text_row_at_end
== NULL
)
16218 /* Displayed to end of window, but no line containing text was
16219 displayed. Lines were deleted at the end of the window. */
16220 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
16221 int vpos
= XFASTINT (w
->window_end_vpos
);
16222 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
16223 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
16226 row
== NULL
&& vpos
>= first_vpos
;
16227 --vpos
, --current_row
, --desired_row
)
16229 if (desired_row
->enabled_p
)
16231 if (desired_row
->displays_text_p
)
16234 else if (current_row
->displays_text_p
)
16238 xassert (row
!= NULL
);
16239 w
->window_end_vpos
= make_number (vpos
+ 1);
16240 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
16241 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
16242 xassert (w
->window_end_bytepos
>= 0);
16243 IF_DEBUG (debug_method_add (w
, "C"));
16248 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
16249 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
16251 /* Record that display has not been completed. */
16252 w
->window_end_valid
= Qnil
;
16253 w
->desired_matrix
->no_scrolling_p
= 1;
16261 /***********************************************************************
16262 More debugging support
16263 ***********************************************************************/
16267 void dump_glyph_row (struct glyph_row
*, int, int);
16268 void dump_glyph_matrix (struct glyph_matrix
*, int);
16269 void dump_glyph (struct glyph_row
*, struct glyph
*, int);
16272 /* Dump the contents of glyph matrix MATRIX on stderr.
16274 GLYPHS 0 means don't show glyph contents.
16275 GLYPHS 1 means show glyphs in short form
16276 GLYPHS > 1 means show glyphs in long form. */
16279 dump_glyph_matrix (struct glyph_matrix
*matrix
, int glyphs
)
16282 for (i
= 0; i
< matrix
->nrows
; ++i
)
16283 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
16287 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
16288 the glyph row and area where the glyph comes from. */
16291 dump_glyph (struct glyph_row
*row
, struct glyph
*glyph
, int area
)
16293 if (glyph
->type
== CHAR_GLYPH
)
16296 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16297 glyph
- row
->glyphs
[TEXT_AREA
],
16300 (BUFFERP (glyph
->object
)
16302 : (STRINGP (glyph
->object
)
16305 glyph
->pixel_width
,
16307 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
16311 glyph
->left_box_line_p
,
16312 glyph
->right_box_line_p
);
16314 else if (glyph
->type
== STRETCH_GLYPH
)
16317 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16318 glyph
- row
->glyphs
[TEXT_AREA
],
16321 (BUFFERP (glyph
->object
)
16323 : (STRINGP (glyph
->object
)
16326 glyph
->pixel_width
,
16330 glyph
->left_box_line_p
,
16331 glyph
->right_box_line_p
);
16333 else if (glyph
->type
== IMAGE_GLYPH
)
16336 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16337 glyph
- row
->glyphs
[TEXT_AREA
],
16340 (BUFFERP (glyph
->object
)
16342 : (STRINGP (glyph
->object
)
16345 glyph
->pixel_width
,
16349 glyph
->left_box_line_p
,
16350 glyph
->right_box_line_p
);
16352 else if (glyph
->type
== COMPOSITE_GLYPH
)
16355 " %5d %4c %6d %c %3d 0x%05x",
16356 glyph
- row
->glyphs
[TEXT_AREA
],
16359 (BUFFERP (glyph
->object
)
16361 : (STRINGP (glyph
->object
)
16364 glyph
->pixel_width
,
16366 if (glyph
->u
.cmp
.automatic
)
16369 glyph
->slice
.cmp
.from
, glyph
->slice
.cmp
.to
);
16370 fprintf (stderr
, " . %4d %1.1d%1.1d\n",
16372 glyph
->left_box_line_p
,
16373 glyph
->right_box_line_p
);
16378 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
16379 GLYPHS 0 means don't show glyph contents.
16380 GLYPHS 1 means show glyphs in short form
16381 GLYPHS > 1 means show glyphs in long form. */
16384 dump_glyph_row (struct glyph_row
*row
, int vpos
, int glyphs
)
16388 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
16389 fprintf (stderr
, "======================================================================\n");
16391 fprintf (stderr
, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
16392 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
16394 MATRIX_ROW_START_CHARPOS (row
),
16395 MATRIX_ROW_END_CHARPOS (row
),
16396 row
->used
[TEXT_AREA
],
16397 row
->contains_overlapping_glyphs_p
,
16399 row
->truncated_on_left_p
,
16400 row
->truncated_on_right_p
,
16402 MATRIX_ROW_CONTINUATION_LINE_P (row
),
16403 row
->displays_text_p
,
16406 row
->ends_in_middle_of_char_p
,
16407 row
->starts_in_middle_of_char_p
,
16413 row
->visible_height
,
16416 fprintf (stderr
, "%9d %5d\t%5d\n", row
->start
.overlay_string_index
,
16417 row
->end
.overlay_string_index
,
16418 row
->continuation_lines_width
);
16419 fprintf (stderr
, "%9d %5d\n",
16420 CHARPOS (row
->start
.string_pos
),
16421 CHARPOS (row
->end
.string_pos
));
16422 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
16423 row
->end
.dpvec_index
);
16430 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
16432 struct glyph
*glyph
= row
->glyphs
[area
];
16433 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
16435 /* Glyph for a line end in text. */
16436 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
16439 if (glyph
< glyph_end
)
16440 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
16442 for (; glyph
< glyph_end
; ++glyph
)
16443 dump_glyph (row
, glyph
, area
);
16446 else if (glyphs
== 1)
16450 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
16452 char *s
= (char *) alloca (row
->used
[area
] + 1);
16455 for (i
= 0; i
< row
->used
[area
]; ++i
)
16457 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
16458 if (glyph
->type
== CHAR_GLYPH
16459 && glyph
->u
.ch
< 0x80
16460 && glyph
->u
.ch
>= ' ')
16461 s
[i
] = glyph
->u
.ch
;
16467 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
16473 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
16474 Sdump_glyph_matrix
, 0, 1, "p",
16475 doc
: /* Dump the current matrix of the selected window to stderr.
16476 Shows contents of glyph row structures. With non-nil
16477 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
16478 glyphs in short form, otherwise show glyphs in long form. */)
16479 (Lisp_Object glyphs
)
16481 struct window
*w
= XWINDOW (selected_window
);
16482 struct buffer
*buffer
= XBUFFER (w
->buffer
);
16484 fprintf (stderr
, "PT = %d, BEGV = %d. ZV = %d\n",
16485 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
16486 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
16487 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
16488 fprintf (stderr
, "=============================================\n");
16489 dump_glyph_matrix (w
->current_matrix
,
16490 NILP (glyphs
) ? 0 : XINT (glyphs
));
16495 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
16496 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
16499 struct frame
*f
= XFRAME (selected_frame
);
16500 dump_glyph_matrix (f
->current_matrix
, 1);
16505 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
16506 doc
: /* Dump glyph row ROW to stderr.
16507 GLYPH 0 means don't dump glyphs.
16508 GLYPH 1 means dump glyphs in short form.
16509 GLYPH > 1 or omitted means dump glyphs in long form. */)
16510 (Lisp_Object row
, Lisp_Object glyphs
)
16512 struct glyph_matrix
*matrix
;
16515 CHECK_NUMBER (row
);
16516 matrix
= XWINDOW (selected_window
)->current_matrix
;
16518 if (vpos
>= 0 && vpos
< matrix
->nrows
)
16519 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
16521 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
16526 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
16527 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
16528 GLYPH 0 means don't dump glyphs.
16529 GLYPH 1 means dump glyphs in short form.
16530 GLYPH > 1 or omitted means dump glyphs in long form. */)
16531 (Lisp_Object row
, Lisp_Object glyphs
)
16533 struct frame
*sf
= SELECTED_FRAME ();
16534 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
16537 CHECK_NUMBER (row
);
16539 if (vpos
>= 0 && vpos
< m
->nrows
)
16540 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
16541 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
16546 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
16547 doc
: /* Toggle tracing of redisplay.
16548 With ARG, turn tracing on if and only if ARG is positive. */)
16552 trace_redisplay_p
= !trace_redisplay_p
;
16555 arg
= Fprefix_numeric_value (arg
);
16556 trace_redisplay_p
= XINT (arg
) > 0;
16563 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
16564 doc
: /* Like `format', but print result to stderr.
16565 usage: (trace-to-stderr STRING &rest OBJECTS) */)
16566 (ptrdiff_t nargs
, Lisp_Object
*args
)
16568 Lisp_Object s
= Fformat (nargs
, args
);
16569 fprintf (stderr
, "%s", SDATA (s
));
16573 #endif /* GLYPH_DEBUG */
16577 /***********************************************************************
16578 Building Desired Matrix Rows
16579 ***********************************************************************/
16581 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
16582 Used for non-window-redisplay windows, and for windows w/o left fringe. */
16584 static struct glyph_row
*
16585 get_overlay_arrow_glyph_row (struct window
*w
, Lisp_Object overlay_arrow_string
)
16587 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
16588 struct buffer
*buffer
= XBUFFER (w
->buffer
);
16589 struct buffer
*old
= current_buffer
;
16590 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
16591 int arrow_len
= SCHARS (overlay_arrow_string
);
16592 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
16593 const unsigned char *p
;
16596 int n_glyphs_before
;
16598 set_buffer_temp (buffer
);
16599 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
16600 it
.glyph_row
->used
[TEXT_AREA
] = 0;
16601 SET_TEXT_POS (it
.position
, 0, 0);
16603 multibyte_p
= !NILP (BVAR (buffer
, enable_multibyte_characters
));
16605 while (p
< arrow_end
)
16607 Lisp_Object face
, ilisp
;
16609 /* Get the next character. */
16611 it
.c
= it
.char_to_display
= string_char_and_length (p
, &it
.len
);
16614 it
.c
= it
.char_to_display
= *p
, it
.len
= 1;
16615 if (! ASCII_CHAR_P (it
.c
))
16616 it
.char_to_display
= BYTE8_TO_CHAR (it
.c
);
16620 /* Get its face. */
16621 ilisp
= make_number (p
- arrow_string
);
16622 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
16623 it
.face_id
= compute_char_face (f
, it
.char_to_display
, face
);
16625 /* Compute its width, get its glyphs. */
16626 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
16627 SET_TEXT_POS (it
.position
, -1, -1);
16628 PRODUCE_GLYPHS (&it
);
16630 /* If this character doesn't fit any more in the line, we have
16631 to remove some glyphs. */
16632 if (it
.current_x
> it
.last_visible_x
)
16634 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
16639 set_buffer_temp (old
);
16640 return it
.glyph_row
;
16644 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
16645 glyphs are only inserted for terminal frames since we can't really
16646 win with truncation glyphs when partially visible glyphs are
16647 involved. Which glyphs to insert is determined by
16648 produce_special_glyphs. */
16651 insert_left_trunc_glyphs (struct it
*it
)
16653 struct it truncate_it
;
16654 struct glyph
*from
, *end
, *to
, *toend
;
16656 xassert (!FRAME_WINDOW_P (it
->f
));
16658 /* Get the truncation glyphs. */
16660 truncate_it
.current_x
= 0;
16661 truncate_it
.face_id
= DEFAULT_FACE_ID
;
16662 truncate_it
.glyph_row
= &scratch_glyph_row
;
16663 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
16664 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
16665 truncate_it
.object
= make_number (0);
16666 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
16668 /* Overwrite glyphs from IT with truncation glyphs. */
16669 if (!it
->glyph_row
->reversed_p
)
16671 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
16672 end
= from
+ truncate_it
.glyph_row
->used
[TEXT_AREA
];
16673 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
16674 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
16679 /* There may be padding glyphs left over. Overwrite them too. */
16680 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
16682 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
16688 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
16692 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
16693 that back to front. */
16694 end
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
16695 from
= end
+ truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
16696 toend
= it
->glyph_row
->glyphs
[TEXT_AREA
];
16697 to
= toend
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
16699 while (from
>= end
&& to
>= toend
)
16701 while (to
>= toend
&& CHAR_GLYPH_PADDING_P (*to
))
16704 truncate_it
.glyph_row
->glyphs
[TEXT_AREA
]
16705 + truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
16706 while (from
>= end
&& to
>= toend
)
16711 /* Need to free some room before prepending additional
16713 int move_by
= from
- end
+ 1;
16714 struct glyph
*g0
= it
->glyph_row
->glyphs
[TEXT_AREA
];
16715 struct glyph
*g
= g0
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
16717 for ( ; g
>= g0
; g
--)
16719 while (from
>= end
)
16721 it
->glyph_row
->used
[TEXT_AREA
] += move_by
;
16727 /* Compute the pixel height and width of IT->glyph_row.
16729 Most of the time, ascent and height of a display line will be equal
16730 to the max_ascent and max_height values of the display iterator
16731 structure. This is not the case if
16733 1. We hit ZV without displaying anything. In this case, max_ascent
16734 and max_height will be zero.
16736 2. We have some glyphs that don't contribute to the line height.
16737 (The glyph row flag contributes_to_line_height_p is for future
16738 pixmap extensions).
16740 The first case is easily covered by using default values because in
16741 these cases, the line height does not really matter, except that it
16742 must not be zero. */
16745 compute_line_metrics (struct it
*it
)
16747 struct glyph_row
*row
= it
->glyph_row
;
16749 if (FRAME_WINDOW_P (it
->f
))
16751 int i
, min_y
, max_y
;
16753 /* The line may consist of one space only, that was added to
16754 place the cursor on it. If so, the row's height hasn't been
16756 if (row
->height
== 0)
16758 if (it
->max_ascent
+ it
->max_descent
== 0)
16759 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
16760 row
->ascent
= it
->max_ascent
;
16761 row
->height
= it
->max_ascent
+ it
->max_descent
;
16762 row
->phys_ascent
= it
->max_phys_ascent
;
16763 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
16764 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
16767 /* Compute the width of this line. */
16768 row
->pixel_width
= row
->x
;
16769 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
16770 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
16772 xassert (row
->pixel_width
>= 0);
16773 xassert (row
->ascent
>= 0 && row
->height
> 0);
16775 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
16776 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
16778 /* If first line's physical ascent is larger than its logical
16779 ascent, use the physical ascent, and make the row taller.
16780 This makes accented characters fully visible. */
16781 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
16782 && row
->phys_ascent
> row
->ascent
)
16784 row
->height
+= row
->phys_ascent
- row
->ascent
;
16785 row
->ascent
= row
->phys_ascent
;
16788 /* Compute how much of the line is visible. */
16789 row
->visible_height
= row
->height
;
16791 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
16792 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
16794 if (row
->y
< min_y
)
16795 row
->visible_height
-= min_y
- row
->y
;
16796 if (row
->y
+ row
->height
> max_y
)
16797 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
16801 row
->pixel_width
= row
->used
[TEXT_AREA
];
16802 if (row
->continued_p
)
16803 row
->pixel_width
-= it
->continuation_pixel_width
;
16804 else if (row
->truncated_on_right_p
)
16805 row
->pixel_width
-= it
->truncation_pixel_width
;
16806 row
->ascent
= row
->phys_ascent
= 0;
16807 row
->height
= row
->phys_height
= row
->visible_height
= 1;
16808 row
->extra_line_spacing
= 0;
16811 /* Compute a hash code for this row. */
16815 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
16816 for (i
= 0; i
< row
->used
[area
]; ++i
)
16817 row
->hash
= ((((row
->hash
<< 4) + (row
->hash
>> 24)) & 0x0fffffff)
16818 + row
->glyphs
[area
][i
].u
.val
16819 + row
->glyphs
[area
][i
].face_id
16820 + row
->glyphs
[area
][i
].padding_p
16821 + (row
->glyphs
[area
][i
].type
<< 2));
16824 it
->max_ascent
= it
->max_descent
= 0;
16825 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
16829 /* Append one space to the glyph row of iterator IT if doing a
16830 window-based redisplay. The space has the same face as
16831 IT->face_id. Value is non-zero if a space was added.
16833 This function is called to make sure that there is always one glyph
16834 at the end of a glyph row that the cursor can be set on under
16835 window-systems. (If there weren't such a glyph we would not know
16836 how wide and tall a box cursor should be displayed).
16838 At the same time this space let's a nicely handle clearing to the
16839 end of the line if the row ends in italic text. */
16842 append_space_for_newline (struct it
*it
, int default_face_p
)
16844 if (FRAME_WINDOW_P (it
->f
))
16846 int n
= it
->glyph_row
->used
[TEXT_AREA
];
16848 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
16849 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
16851 /* Save some values that must not be changed.
16852 Must save IT->c and IT->len because otherwise
16853 ITERATOR_AT_END_P wouldn't work anymore after
16854 append_space_for_newline has been called. */
16855 enum display_element_type saved_what
= it
->what
;
16856 int saved_c
= it
->c
, saved_len
= it
->len
;
16857 int saved_char_to_display
= it
->char_to_display
;
16858 int saved_x
= it
->current_x
;
16859 int saved_face_id
= it
->face_id
;
16860 struct text_pos saved_pos
;
16861 Lisp_Object saved_object
;
16864 saved_object
= it
->object
;
16865 saved_pos
= it
->position
;
16867 it
->what
= IT_CHARACTER
;
16868 memset (&it
->position
, 0, sizeof it
->position
);
16869 it
->object
= make_number (0);
16870 it
->c
= it
->char_to_display
= ' ';
16873 if (default_face_p
)
16874 it
->face_id
= DEFAULT_FACE_ID
;
16875 else if (it
->face_before_selective_p
)
16876 it
->face_id
= it
->saved_face_id
;
16877 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
16878 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
16880 PRODUCE_GLYPHS (it
);
16882 it
->override_ascent
= -1;
16883 it
->constrain_row_ascent_descent_p
= 0;
16884 it
->current_x
= saved_x
;
16885 it
->object
= saved_object
;
16886 it
->position
= saved_pos
;
16887 it
->what
= saved_what
;
16888 it
->face_id
= saved_face_id
;
16889 it
->len
= saved_len
;
16891 it
->char_to_display
= saved_char_to_display
;
16900 /* Extend the face of the last glyph in the text area of IT->glyph_row
16901 to the end of the display line. Called from display_line. If the
16902 glyph row is empty, add a space glyph to it so that we know the
16903 face to draw. Set the glyph row flag fill_line_p. If the glyph
16904 row is R2L, prepend a stretch glyph to cover the empty space to the
16905 left of the leftmost glyph. */
16908 extend_face_to_end_of_line (struct it
*it
)
16911 struct frame
*f
= it
->f
;
16913 /* If line is already filled, do nothing. Non window-system frames
16914 get a grace of one more ``pixel'' because their characters are
16915 1-``pixel'' wide, so they hit the equality too early. This grace
16916 is needed only for R2L rows that are not continued, to produce
16917 one extra blank where we could display the cursor. */
16918 if (it
->current_x
>= it
->last_visible_x
16919 + (!FRAME_WINDOW_P (f
)
16920 && it
->glyph_row
->reversed_p
16921 && !it
->glyph_row
->continued_p
))
16924 /* Face extension extends the background and box of IT->face_id
16925 to the end of the line. If the background equals the background
16926 of the frame, we don't have to do anything. */
16927 if (it
->face_before_selective_p
)
16928 face
= FACE_FROM_ID (f
, it
->saved_face_id
);
16930 face
= FACE_FROM_ID (f
, it
->face_id
);
16932 if (FRAME_WINDOW_P (f
)
16933 && it
->glyph_row
->displays_text_p
16934 && face
->box
== FACE_NO_BOX
16935 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
16937 && !it
->glyph_row
->reversed_p
)
16940 /* Set the glyph row flag indicating that the face of the last glyph
16941 in the text area has to be drawn to the end of the text area. */
16942 it
->glyph_row
->fill_line_p
= 1;
16944 /* If current character of IT is not ASCII, make sure we have the
16945 ASCII face. This will be automatically undone the next time
16946 get_next_display_element returns a multibyte character. Note
16947 that the character will always be single byte in unibyte
16949 if (!ASCII_CHAR_P (it
->c
))
16951 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
16954 if (FRAME_WINDOW_P (f
))
16956 /* If the row is empty, add a space with the current face of IT,
16957 so that we know which face to draw. */
16958 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
16960 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
16961 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= it
->face_id
;
16962 it
->glyph_row
->used
[TEXT_AREA
] = 1;
16964 #ifdef HAVE_WINDOW_SYSTEM
16965 if (it
->glyph_row
->reversed_p
)
16967 /* Prepend a stretch glyph to the row, such that the
16968 rightmost glyph will be drawn flushed all the way to the
16969 right margin of the window. The stretch glyph that will
16970 occupy the empty space, if any, to the left of the
16972 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (f
);
16973 struct glyph
*row_start
= it
->glyph_row
->glyphs
[TEXT_AREA
];
16974 struct glyph
*row_end
= row_start
+ it
->glyph_row
->used
[TEXT_AREA
];
16976 int row_width
, stretch_ascent
, stretch_width
;
16977 struct text_pos saved_pos
;
16978 int saved_face_id
, saved_avoid_cursor
;
16980 for (row_width
= 0, g
= row_start
; g
< row_end
; g
++)
16981 row_width
+= g
->pixel_width
;
16982 stretch_width
= window_box_width (it
->w
, TEXT_AREA
) - row_width
;
16983 if (stretch_width
> 0)
16986 (((it
->ascent
+ it
->descent
)
16987 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
16988 saved_pos
= it
->position
;
16989 memset (&it
->position
, 0, sizeof it
->position
);
16990 saved_avoid_cursor
= it
->avoid_cursor_p
;
16991 it
->avoid_cursor_p
= 1;
16992 saved_face_id
= it
->face_id
;
16993 /* The last row's stretch glyph should get the default
16994 face, to avoid painting the rest of the window with
16995 the region face, if the region ends at ZV. */
16996 if (it
->glyph_row
->ends_at_zv_p
)
16997 it
->face_id
= DEFAULT_FACE_ID
;
16999 it
->face_id
= face
->id
;
17000 append_stretch_glyph (it
, make_number (0), stretch_width
,
17001 it
->ascent
+ it
->descent
, stretch_ascent
);
17002 it
->position
= saved_pos
;
17003 it
->avoid_cursor_p
= saved_avoid_cursor
;
17004 it
->face_id
= saved_face_id
;
17007 #endif /* HAVE_WINDOW_SYSTEM */
17011 /* Save some values that must not be changed. */
17012 int saved_x
= it
->current_x
;
17013 struct text_pos saved_pos
;
17014 Lisp_Object saved_object
;
17015 enum display_element_type saved_what
= it
->what
;
17016 int saved_face_id
= it
->face_id
;
17018 saved_object
= it
->object
;
17019 saved_pos
= it
->position
;
17021 it
->what
= IT_CHARACTER
;
17022 memset (&it
->position
, 0, sizeof it
->position
);
17023 it
->object
= make_number (0);
17024 it
->c
= it
->char_to_display
= ' ';
17026 /* The last row's blank glyphs should get the default face, to
17027 avoid painting the rest of the window with the region face,
17028 if the region ends at ZV. */
17029 if (it
->glyph_row
->ends_at_zv_p
)
17030 it
->face_id
= DEFAULT_FACE_ID
;
17032 it
->face_id
= face
->id
;
17034 PRODUCE_GLYPHS (it
);
17036 while (it
->current_x
<= it
->last_visible_x
)
17037 PRODUCE_GLYPHS (it
);
17039 /* Don't count these blanks really. It would let us insert a left
17040 truncation glyph below and make us set the cursor on them, maybe. */
17041 it
->current_x
= saved_x
;
17042 it
->object
= saved_object
;
17043 it
->position
= saved_pos
;
17044 it
->what
= saved_what
;
17045 it
->face_id
= saved_face_id
;
17050 /* Value is non-zero if text starting at CHARPOS in current_buffer is
17051 trailing whitespace. */
17054 trailing_whitespace_p (EMACS_INT charpos
)
17056 EMACS_INT bytepos
= CHAR_TO_BYTE (charpos
);
17059 while (bytepos
< ZV_BYTE
17060 && (c
= FETCH_CHAR (bytepos
),
17061 c
== ' ' || c
== '\t'))
17064 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
17066 if (bytepos
!= PT_BYTE
)
17073 /* Highlight trailing whitespace, if any, in ROW. */
17076 highlight_trailing_whitespace (struct frame
*f
, struct glyph_row
*row
)
17078 int used
= row
->used
[TEXT_AREA
];
17082 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
17083 struct glyph
*glyph
= start
+ used
- 1;
17085 if (row
->reversed_p
)
17087 /* Right-to-left rows need to be processed in the opposite
17088 direction, so swap the edge pointers. */
17090 start
= row
->glyphs
[TEXT_AREA
] + used
- 1;
17093 /* Skip over glyphs inserted to display the cursor at the
17094 end of a line, for extending the face of the last glyph
17095 to the end of the line on terminals, and for truncation
17096 and continuation glyphs. */
17097 if (!row
->reversed_p
)
17099 while (glyph
>= start
17100 && glyph
->type
== CHAR_GLYPH
17101 && INTEGERP (glyph
->object
))
17106 while (glyph
<= start
17107 && glyph
->type
== CHAR_GLYPH
17108 && INTEGERP (glyph
->object
))
17112 /* If last glyph is a space or stretch, and it's trailing
17113 whitespace, set the face of all trailing whitespace glyphs in
17114 IT->glyph_row to `trailing-whitespace'. */
17115 if ((row
->reversed_p
? glyph
<= start
: glyph
>= start
)
17116 && BUFFERP (glyph
->object
)
17117 && (glyph
->type
== STRETCH_GLYPH
17118 || (glyph
->type
== CHAR_GLYPH
17119 && glyph
->u
.ch
== ' '))
17120 && trailing_whitespace_p (glyph
->charpos
))
17122 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
17126 if (!row
->reversed_p
)
17128 while (glyph
>= start
17129 && BUFFERP (glyph
->object
)
17130 && (glyph
->type
== STRETCH_GLYPH
17131 || (glyph
->type
== CHAR_GLYPH
17132 && glyph
->u
.ch
== ' ')))
17133 (glyph
--)->face_id
= face_id
;
17137 while (glyph
<= start
17138 && BUFFERP (glyph
->object
)
17139 && (glyph
->type
== STRETCH_GLYPH
17140 || (glyph
->type
== CHAR_GLYPH
17141 && glyph
->u
.ch
== ' ')))
17142 (glyph
++)->face_id
= face_id
;
17149 /* Value is non-zero if glyph row ROW should be
17150 used to hold the cursor. */
17153 cursor_row_p (struct glyph_row
*row
)
17157 if (PT
== CHARPOS (row
->end
.pos
))
17159 /* Suppose the row ends on a string.
17160 Unless the row is continued, that means it ends on a newline
17161 in the string. If it's anything other than a display string
17162 (e.g. a before-string from an overlay), we don't want the
17163 cursor there. (This heuristic seems to give the optimal
17164 behavior for the various types of multi-line strings.) */
17165 if (CHARPOS (row
->end
.string_pos
) >= 0)
17167 if (row
->continued_p
)
17171 /* Check for `display' property. */
17172 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
17173 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
17174 struct glyph
*glyph
;
17177 for (glyph
= end
; glyph
>= beg
; --glyph
)
17178 if (STRINGP (glyph
->object
))
17181 = Fget_char_property (make_number (PT
),
17185 && display_prop_string_p (prop
, glyph
->object
));
17190 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
17192 /* If the row ends in middle of a real character,
17193 and the line is continued, we want the cursor here.
17194 That's because CHARPOS (ROW->end.pos) would equal
17195 PT if PT is before the character. */
17196 if (!row
->ends_in_ellipsis_p
)
17197 result
= row
->continued_p
;
17199 /* If the row ends in an ellipsis, then
17200 CHARPOS (ROW->end.pos) will equal point after the
17201 invisible text. We want that position to be displayed
17202 after the ellipsis. */
17205 /* If the row ends at ZV, display the cursor at the end of that
17206 row instead of at the start of the row below. */
17207 else if (row
->ends_at_zv_p
)
17218 /* Push the display property PROP so that it will be rendered at the
17219 current position in IT. Return 1 if PROP was successfully pushed,
17223 push_display_prop (struct it
*it
, Lisp_Object prop
)
17225 push_it (it
, NULL
);
17227 if (STRINGP (prop
))
17229 if (SCHARS (prop
) == 0)
17236 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
17237 it
->current
.overlay_string_index
= -1;
17238 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
17239 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
17240 it
->method
= GET_FROM_STRING
;
17241 it
->stop_charpos
= 0;
17243 else if (CONSP (prop
) && EQ (XCAR (prop
), Qspace
))
17245 it
->method
= GET_FROM_STRETCH
;
17248 #ifdef HAVE_WINDOW_SYSTEM
17249 else if (IMAGEP (prop
))
17251 it
->what
= IT_IMAGE
;
17252 it
->image_id
= lookup_image (it
->f
, prop
);
17253 it
->method
= GET_FROM_IMAGE
;
17255 #endif /* HAVE_WINDOW_SYSTEM */
17258 pop_it (it
); /* bogus display property, give up */
17265 /* Return the character-property PROP at the current position in IT. */
17268 get_it_property (struct it
*it
, Lisp_Object prop
)
17270 Lisp_Object position
;
17272 if (STRINGP (it
->object
))
17273 position
= make_number (IT_STRING_CHARPOS (*it
));
17274 else if (BUFFERP (it
->object
))
17275 position
= make_number (IT_CHARPOS (*it
));
17279 return Fget_char_property (position
, prop
, it
->object
);
17282 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
17285 handle_line_prefix (struct it
*it
)
17287 Lisp_Object prefix
;
17288 if (it
->continuation_lines_width
> 0)
17290 prefix
= get_it_property (it
, Qwrap_prefix
);
17292 prefix
= Vwrap_prefix
;
17296 prefix
= get_it_property (it
, Qline_prefix
);
17298 prefix
= Vline_prefix
;
17300 if (! NILP (prefix
) && push_display_prop (it
, prefix
))
17302 /* If the prefix is wider than the window, and we try to wrap
17303 it, it would acquire its own wrap prefix, and so on till the
17304 iterator stack overflows. So, don't wrap the prefix. */
17305 it
->line_wrap
= TRUNCATE
;
17306 it
->avoid_cursor_p
= 1;
17312 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
17313 only for R2L lines from display_line, when it decides that too many
17314 glyphs were produced by PRODUCE_GLYPHS, and the line needs to be
17317 unproduce_glyphs (struct it
*it
, int n
)
17319 struct glyph
*glyph
, *end
;
17321 xassert (it
->glyph_row
);
17322 xassert (it
->glyph_row
->reversed_p
);
17323 xassert (it
->area
== TEXT_AREA
);
17324 xassert (n
<= it
->glyph_row
->used
[TEXT_AREA
]);
17326 if (n
> it
->glyph_row
->used
[TEXT_AREA
])
17327 n
= it
->glyph_row
->used
[TEXT_AREA
];
17328 glyph
= it
->glyph_row
->glyphs
[TEXT_AREA
] + n
;
17329 end
= it
->glyph_row
->glyphs
[TEXT_AREA
] + it
->glyph_row
->used
[TEXT_AREA
];
17330 for ( ; glyph
< end
; glyph
++)
17331 glyph
[-n
] = *glyph
;
17334 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
17335 and ROW->maxpos. */
17337 find_row_edges (struct it
*it
, struct glyph_row
*row
,
17338 EMACS_INT min_pos
, EMACS_INT min_bpos
,
17339 EMACS_INT max_pos
, EMACS_INT max_bpos
)
17341 /* FIXME: Revisit this when glyph ``spilling'' in continuation
17342 lines' rows is implemented for bidi-reordered rows. */
17344 /* ROW->minpos is the value of min_pos, the minimal buffer position
17347 SET_TEXT_POS (row
->minpos
, min_pos
, min_bpos
);
17349 /* We didn't find _any_ valid buffer positions in any of the
17350 glyphs, so we must trust the iterator's computed positions. */
17351 row
->minpos
= row
->start
.pos
;
17354 max_pos
= CHARPOS (it
->current
.pos
);
17355 max_bpos
= BYTEPOS (it
->current
.pos
);
17358 /* Here are the various use-cases for ending the row, and the
17359 corresponding values for ROW->maxpos:
17361 Line ends in a newline from buffer eol_pos + 1
17362 Line is continued from buffer max_pos + 1
17363 Line is truncated on right it->current.pos
17364 Line ends in a newline from string max_pos
17365 Line is continued from string max_pos
17366 Line is continued from display vector max_pos
17367 Line is entirely from a string min_pos == max_pos
17368 Line is entirely from a display vector min_pos == max_pos
17369 Line that ends at ZV ZV
17371 If you discover other use-cases, please add them here as
17373 if (row
->ends_at_zv_p
)
17374 row
->maxpos
= it
->current
.pos
;
17375 else if (row
->used
[TEXT_AREA
])
17377 if (row
->ends_in_newline_from_string_p
)
17378 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
17379 else if (CHARPOS (it
->eol_pos
) > 0)
17380 SET_TEXT_POS (row
->maxpos
,
17381 CHARPOS (it
->eol_pos
) + 1, BYTEPOS (it
->eol_pos
) + 1);
17382 else if (row
->continued_p
)
17384 /* If max_pos is different from IT's current position, it
17385 means IT->method does not belong to the display element
17386 at max_pos. However, it also means that the display
17387 element at max_pos was displayed in its entirety on this
17388 line, which is equivalent to saying that the next line
17389 starts at the next buffer position. */
17390 if (IT_CHARPOS (*it
) == max_pos
&& it
->method
!= GET_FROM_BUFFER
)
17391 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
17394 INC_BOTH (max_pos
, max_bpos
);
17395 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
17398 else if (row
->truncated_on_right_p
)
17399 /* display_line already called reseat_at_next_visible_line_start,
17400 which puts the iterator at the beginning of the next line, in
17401 the logical order. */
17402 row
->maxpos
= it
->current
.pos
;
17403 else if (max_pos
== min_pos
&& it
->method
!= GET_FROM_BUFFER
)
17404 /* A line that is entirely from a string/image/stretch... */
17405 row
->maxpos
= row
->minpos
;
17410 row
->maxpos
= it
->current
.pos
;
17413 /* Construct the glyph row IT->glyph_row in the desired matrix of
17414 IT->w from text at the current position of IT. See dispextern.h
17415 for an overview of struct it. Value is non-zero if
17416 IT->glyph_row displays text, as opposed to a line displaying ZV
17420 display_line (struct it
*it
)
17422 struct glyph_row
*row
= it
->glyph_row
;
17423 Lisp_Object overlay_arrow_string
;
17425 int may_wrap
= 0, wrap_x
IF_LINT (= 0);
17426 int wrap_row_used
= -1;
17427 int wrap_row_ascent
IF_LINT (= 0), wrap_row_height
IF_LINT (= 0);
17428 int wrap_row_phys_ascent
IF_LINT (= 0), wrap_row_phys_height
IF_LINT (= 0);
17429 int wrap_row_extra_line_spacing
IF_LINT (= 0);
17430 EMACS_INT wrap_row_min_pos
IF_LINT (= 0), wrap_row_min_bpos
IF_LINT (= 0);
17431 EMACS_INT wrap_row_max_pos
IF_LINT (= 0), wrap_row_max_bpos
IF_LINT (= 0);
17433 EMACS_INT min_pos
= ZV
+ 1, max_pos
= 0;
17434 EMACS_INT min_bpos
IF_LINT (= 0), max_bpos
IF_LINT (= 0);
17436 /* We always start displaying at hpos zero even if hscrolled. */
17437 xassert (it
->hpos
== 0 && it
->current_x
== 0);
17439 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
17440 >= it
->w
->desired_matrix
->nrows
)
17442 it
->w
->nrows_scale_factor
++;
17443 fonts_changed_p
= 1;
17447 /* Is IT->w showing the region? */
17448 it
->w
->region_showing
= it
->region_beg_charpos
> 0 ? Qt
: Qnil
;
17450 /* Clear the result glyph row and enable it. */
17451 prepare_desired_row (row
);
17453 row
->y
= it
->current_y
;
17454 row
->start
= it
->start
;
17455 row
->continuation_lines_width
= it
->continuation_lines_width
;
17456 row
->displays_text_p
= 1;
17457 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
17458 it
->starts_in_middle_of_char_p
= 0;
17460 /* Arrange the overlays nicely for our purposes. Usually, we call
17461 display_line on only one line at a time, in which case this
17462 can't really hurt too much, or we call it on lines which appear
17463 one after another in the buffer, in which case all calls to
17464 recenter_overlay_lists but the first will be pretty cheap. */
17465 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
17467 /* Move over display elements that are not visible because we are
17468 hscrolled. This may stop at an x-position < IT->first_visible_x
17469 if the first glyph is partially visible or if we hit a line end. */
17470 if (it
->current_x
< it
->first_visible_x
)
17472 this_line_min_pos
= row
->start
.pos
;
17473 move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
17474 MOVE_TO_POS
| MOVE_TO_X
);
17475 /* Record the smallest positions seen while we moved over
17476 display elements that are not visible. This is needed by
17477 redisplay_internal for optimizing the case where the cursor
17478 stays inside the same line. The rest of this function only
17479 considers positions that are actually displayed, so
17480 RECORD_MAX_MIN_POS will not otherwise record positions that
17481 are hscrolled to the left of the left edge of the window. */
17482 min_pos
= CHARPOS (this_line_min_pos
);
17483 min_bpos
= BYTEPOS (this_line_min_pos
);
17487 /* We only do this when not calling `move_it_in_display_line_to'
17488 above, because move_it_in_display_line_to calls
17489 handle_line_prefix itself. */
17490 handle_line_prefix (it
);
17493 /* Get the initial row height. This is either the height of the
17494 text hscrolled, if there is any, or zero. */
17495 row
->ascent
= it
->max_ascent
;
17496 row
->height
= it
->max_ascent
+ it
->max_descent
;
17497 row
->phys_ascent
= it
->max_phys_ascent
;
17498 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
17499 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
17501 /* Utility macro to record max and min buffer positions seen until now. */
17502 #define RECORD_MAX_MIN_POS(IT) \
17505 if (IT_CHARPOS (*(IT)) < min_pos) \
17507 min_pos = IT_CHARPOS (*(IT)); \
17508 min_bpos = IT_BYTEPOS (*(IT)); \
17510 if (IT_CHARPOS (*(IT)) > max_pos) \
17512 max_pos = IT_CHARPOS (*(IT)); \
17513 max_bpos = IT_BYTEPOS (*(IT)); \
17518 /* Loop generating characters. The loop is left with IT on the next
17519 character to display. */
17522 int n_glyphs_before
, hpos_before
, x_before
;
17524 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
17526 /* Retrieve the next thing to display. Value is zero if end of
17528 if (!get_next_display_element (it
))
17530 /* Maybe add a space at the end of this line that is used to
17531 display the cursor there under X. Set the charpos of the
17532 first glyph of blank lines not corresponding to any text
17534 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
17535 row
->exact_window_width_line_p
= 1;
17536 else if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
17537 || row
->used
[TEXT_AREA
] == 0)
17539 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
17540 row
->displays_text_p
= 0;
17542 if (!NILP (BVAR (XBUFFER (it
->w
->buffer
), indicate_empty_lines
))
17543 && (!MINI_WINDOW_P (it
->w
)
17544 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
17545 row
->indicate_empty_line_p
= 1;
17548 it
->continuation_lines_width
= 0;
17549 row
->ends_at_zv_p
= 1;
17550 /* A row that displays right-to-left text must always have
17551 its last face extended all the way to the end of line,
17552 even if this row ends in ZV, because we still write to
17553 the screen left to right. */
17554 if (row
->reversed_p
)
17555 extend_face_to_end_of_line (it
);
17559 /* Now, get the metrics of what we want to display. This also
17560 generates glyphs in `row' (which is IT->glyph_row). */
17561 n_glyphs_before
= row
->used
[TEXT_AREA
];
17564 /* Remember the line height so far in case the next element doesn't
17565 fit on the line. */
17566 if (it
->line_wrap
!= TRUNCATE
)
17568 ascent
= it
->max_ascent
;
17569 descent
= it
->max_descent
;
17570 phys_ascent
= it
->max_phys_ascent
;
17571 phys_descent
= it
->max_phys_descent
;
17573 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
17575 if (IT_DISPLAYING_WHITESPACE (it
))
17581 wrap_row_used
= row
->used
[TEXT_AREA
];
17582 wrap_row_ascent
= row
->ascent
;
17583 wrap_row_height
= row
->height
;
17584 wrap_row_phys_ascent
= row
->phys_ascent
;
17585 wrap_row_phys_height
= row
->phys_height
;
17586 wrap_row_extra_line_spacing
= row
->extra_line_spacing
;
17587 wrap_row_min_pos
= min_pos
;
17588 wrap_row_min_bpos
= min_bpos
;
17589 wrap_row_max_pos
= max_pos
;
17590 wrap_row_max_bpos
= max_bpos
;
17596 PRODUCE_GLYPHS (it
);
17598 /* If this display element was in marginal areas, continue with
17600 if (it
->area
!= TEXT_AREA
)
17602 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
17603 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
17604 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
17605 row
->phys_height
= max (row
->phys_height
,
17606 it
->max_phys_ascent
+ it
->max_phys_descent
);
17607 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
17608 it
->max_extra_line_spacing
);
17609 set_iterator_to_next (it
, 1);
17613 /* Does the display element fit on the line? If we truncate
17614 lines, we should draw past the right edge of the window. If
17615 we don't truncate, we want to stop so that we can display the
17616 continuation glyph before the right margin. If lines are
17617 continued, there are two possible strategies for characters
17618 resulting in more than 1 glyph (e.g. tabs): Display as many
17619 glyphs as possible in this line and leave the rest for the
17620 continuation line, or display the whole element in the next
17621 line. Original redisplay did the former, so we do it also. */
17622 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
17623 hpos_before
= it
->hpos
;
17626 if (/* Not a newline. */
17628 /* Glyphs produced fit entirely in the line. */
17629 && it
->current_x
< it
->last_visible_x
)
17631 it
->hpos
+= nglyphs
;
17632 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
17633 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
17634 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
17635 row
->phys_height
= max (row
->phys_height
,
17636 it
->max_phys_ascent
+ it
->max_phys_descent
);
17637 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
17638 it
->max_extra_line_spacing
);
17639 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
17640 row
->x
= x
- it
->first_visible_x
;
17641 /* Record the maximum and minimum buffer positions seen so
17642 far in glyphs that will be displayed by this row. */
17644 RECORD_MAX_MIN_POS (it
);
17649 struct glyph
*glyph
;
17651 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
17653 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
17654 new_x
= x
+ glyph
->pixel_width
;
17656 if (/* Lines are continued. */
17657 it
->line_wrap
!= TRUNCATE
17658 && (/* Glyph doesn't fit on the line. */
17659 new_x
> it
->last_visible_x
17660 /* Or it fits exactly on a window system frame. */
17661 || (new_x
== it
->last_visible_x
17662 && FRAME_WINDOW_P (it
->f
))))
17664 /* End of a continued line. */
17667 || (new_x
== it
->last_visible_x
17668 && FRAME_WINDOW_P (it
->f
)))
17670 /* Current glyph is the only one on the line or
17671 fits exactly on the line. We must continue
17672 the line because we can't draw the cursor
17673 after the glyph. */
17674 row
->continued_p
= 1;
17675 it
->current_x
= new_x
;
17676 it
->continuation_lines_width
+= new_x
;
17678 /* Record the maximum and minimum buffer
17679 positions seen so far in glyphs that will be
17680 displayed by this row. */
17682 RECORD_MAX_MIN_POS (it
);
17683 if (i
== nglyphs
- 1)
17685 /* If line-wrap is on, check if a previous
17686 wrap point was found. */
17687 if (wrap_row_used
> 0
17688 /* Even if there is a previous wrap
17689 point, continue the line here as
17690 usual, if (i) the previous character
17691 was a space or tab AND (ii) the
17692 current character is not. */
17694 || IT_DISPLAYING_WHITESPACE (it
)))
17697 set_iterator_to_next (it
, 1);
17698 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
17700 if (!get_next_display_element (it
))
17702 row
->exact_window_width_line_p
= 1;
17703 it
->continuation_lines_width
= 0;
17704 row
->continued_p
= 0;
17705 row
->ends_at_zv_p
= 1;
17707 else if (ITERATOR_AT_END_OF_LINE_P (it
))
17709 row
->continued_p
= 0;
17710 row
->exact_window_width_line_p
= 1;
17715 else if (CHAR_GLYPH_PADDING_P (*glyph
)
17716 && !FRAME_WINDOW_P (it
->f
))
17718 /* A padding glyph that doesn't fit on this line.
17719 This means the whole character doesn't fit
17721 if (row
->reversed_p
)
17722 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
17723 - n_glyphs_before
);
17724 row
->used
[TEXT_AREA
] = n_glyphs_before
;
17726 /* Fill the rest of the row with continuation
17727 glyphs like in 20.x. */
17728 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
17729 < row
->glyphs
[1 + TEXT_AREA
])
17730 produce_special_glyphs (it
, IT_CONTINUATION
);
17732 row
->continued_p
= 1;
17733 it
->current_x
= x_before
;
17734 it
->continuation_lines_width
+= x_before
;
17736 /* Restore the height to what it was before the
17737 element not fitting on the line. */
17738 it
->max_ascent
= ascent
;
17739 it
->max_descent
= descent
;
17740 it
->max_phys_ascent
= phys_ascent
;
17741 it
->max_phys_descent
= phys_descent
;
17743 else if (wrap_row_used
> 0)
17746 if (row
->reversed_p
)
17747 unproduce_glyphs (it
,
17748 row
->used
[TEXT_AREA
] - wrap_row_used
);
17750 it
->continuation_lines_width
+= wrap_x
;
17751 row
->used
[TEXT_AREA
] = wrap_row_used
;
17752 row
->ascent
= wrap_row_ascent
;
17753 row
->height
= wrap_row_height
;
17754 row
->phys_ascent
= wrap_row_phys_ascent
;
17755 row
->phys_height
= wrap_row_phys_height
;
17756 row
->extra_line_spacing
= wrap_row_extra_line_spacing
;
17757 min_pos
= wrap_row_min_pos
;
17758 min_bpos
= wrap_row_min_bpos
;
17759 max_pos
= wrap_row_max_pos
;
17760 max_bpos
= wrap_row_max_bpos
;
17761 row
->continued_p
= 1;
17762 row
->ends_at_zv_p
= 0;
17763 row
->exact_window_width_line_p
= 0;
17764 it
->continuation_lines_width
+= x
;
17766 /* Make sure that a non-default face is extended
17767 up to the right margin of the window. */
17768 extend_face_to_end_of_line (it
);
17770 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
17772 /* A TAB that extends past the right edge of the
17773 window. This produces a single glyph on
17774 window system frames. We leave the glyph in
17775 this row and let it fill the row, but don't
17776 consume the TAB. */
17777 it
->continuation_lines_width
+= it
->last_visible_x
;
17778 row
->ends_in_middle_of_char_p
= 1;
17779 row
->continued_p
= 1;
17780 glyph
->pixel_width
= it
->last_visible_x
- x
;
17781 it
->starts_in_middle_of_char_p
= 1;
17785 /* Something other than a TAB that draws past
17786 the right edge of the window. Restore
17787 positions to values before the element. */
17788 if (row
->reversed_p
)
17789 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
17790 - (n_glyphs_before
+ i
));
17791 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
17793 /* Display continuation glyphs. */
17794 if (!FRAME_WINDOW_P (it
->f
))
17795 produce_special_glyphs (it
, IT_CONTINUATION
);
17796 row
->continued_p
= 1;
17798 it
->current_x
= x_before
;
17799 it
->continuation_lines_width
+= x
;
17800 extend_face_to_end_of_line (it
);
17802 if (nglyphs
> 1 && i
> 0)
17804 row
->ends_in_middle_of_char_p
= 1;
17805 it
->starts_in_middle_of_char_p
= 1;
17808 /* Restore the height to what it was before the
17809 element not fitting on the line. */
17810 it
->max_ascent
= ascent
;
17811 it
->max_descent
= descent
;
17812 it
->max_phys_ascent
= phys_ascent
;
17813 it
->max_phys_descent
= phys_descent
;
17818 else if (new_x
> it
->first_visible_x
)
17820 /* Increment number of glyphs actually displayed. */
17823 /* Record the maximum and minimum buffer positions
17824 seen so far in glyphs that will be displayed by
17827 RECORD_MAX_MIN_POS (it
);
17829 if (x
< it
->first_visible_x
)
17830 /* Glyph is partially visible, i.e. row starts at
17831 negative X position. */
17832 row
->x
= x
- it
->first_visible_x
;
17836 /* Glyph is completely off the left margin of the
17837 window. This should not happen because of the
17838 move_it_in_display_line at the start of this
17839 function, unless the text display area of the
17840 window is empty. */
17841 xassert (it
->first_visible_x
<= it
->last_visible_x
);
17845 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
17846 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
17847 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
17848 row
->phys_height
= max (row
->phys_height
,
17849 it
->max_phys_ascent
+ it
->max_phys_descent
);
17850 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
17851 it
->max_extra_line_spacing
);
17853 /* End of this display line if row is continued. */
17854 if (row
->continued_p
|| row
->ends_at_zv_p
)
17859 /* Is this a line end? If yes, we're also done, after making
17860 sure that a non-default face is extended up to the right
17861 margin of the window. */
17862 if (ITERATOR_AT_END_OF_LINE_P (it
))
17864 int used_before
= row
->used
[TEXT_AREA
];
17866 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
17868 /* Add a space at the end of the line that is used to
17869 display the cursor there. */
17870 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
17871 append_space_for_newline (it
, 0);
17873 /* Extend the face to the end of the line. */
17874 extend_face_to_end_of_line (it
);
17876 /* Make sure we have the position. */
17877 if (used_before
== 0)
17878 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
17880 /* Record the position of the newline, for use in
17882 it
->eol_pos
= it
->current
.pos
;
17884 /* Consume the line end. This skips over invisible lines. */
17885 set_iterator_to_next (it
, 1);
17886 it
->continuation_lines_width
= 0;
17890 /* Proceed with next display element. Note that this skips
17891 over lines invisible because of selective display. */
17892 set_iterator_to_next (it
, 1);
17894 /* If we truncate lines, we are done when the last displayed
17895 glyphs reach past the right margin of the window. */
17896 if (it
->line_wrap
== TRUNCATE
17897 && (FRAME_WINDOW_P (it
->f
)
17898 ? (it
->current_x
>= it
->last_visible_x
)
17899 : (it
->current_x
> it
->last_visible_x
)))
17901 /* Maybe add truncation glyphs. */
17902 if (!FRAME_WINDOW_P (it
->f
))
17906 if (!row
->reversed_p
)
17908 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
17909 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
17914 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
17915 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
17917 /* Remove any padding glyphs at the front of ROW, to
17918 make room for the truncation glyphs we will be
17919 adding below. The loop below always inserts at
17920 least one truncation glyph, so also remove the
17921 last glyph added to ROW. */
17922 unproduce_glyphs (it
, i
+ 1);
17923 /* Adjust i for the loop below. */
17924 i
= row
->used
[TEXT_AREA
] - (i
+ 1);
17927 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
17929 row
->used
[TEXT_AREA
] = i
;
17930 produce_special_glyphs (it
, IT_TRUNCATION
);
17933 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
17935 /* Don't truncate if we can overflow newline into fringe. */
17936 if (!get_next_display_element (it
))
17938 it
->continuation_lines_width
= 0;
17939 row
->ends_at_zv_p
= 1;
17940 row
->exact_window_width_line_p
= 1;
17943 if (ITERATOR_AT_END_OF_LINE_P (it
))
17945 row
->exact_window_width_line_p
= 1;
17946 goto at_end_of_line
;
17950 row
->truncated_on_right_p
= 1;
17951 it
->continuation_lines_width
= 0;
17952 reseat_at_next_visible_line_start (it
, 0);
17953 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
17954 it
->hpos
= hpos_before
;
17955 it
->current_x
= x_before
;
17960 /* If line is not empty and hscrolled, maybe insert truncation glyphs
17961 at the left window margin. */
17962 if (it
->first_visible_x
17963 && IT_CHARPOS (*it
) != CHARPOS (row
->start
.pos
))
17965 if (!FRAME_WINDOW_P (it
->f
))
17966 insert_left_trunc_glyphs (it
);
17967 row
->truncated_on_left_p
= 1;
17970 /* Remember the position at which this line ends.
17972 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
17973 cannot be before the call to find_row_edges below, since that is
17974 where these positions are determined. */
17975 row
->end
= it
->current
;
17978 row
->minpos
= row
->start
.pos
;
17979 row
->maxpos
= row
->end
.pos
;
17983 /* ROW->minpos and ROW->maxpos must be the smallest and
17984 `1 + the largest' buffer positions in ROW. But if ROW was
17985 bidi-reordered, these two positions can be anywhere in the
17986 row, so we must determine them now. */
17987 find_row_edges (it
, row
, min_pos
, min_bpos
, max_pos
, max_bpos
);
17990 /* If the start of this line is the overlay arrow-position, then
17991 mark this glyph row as the one containing the overlay arrow.
17992 This is clearly a mess with variable size fonts. It would be
17993 better to let it be displayed like cursors under X. */
17994 if ((row
->displays_text_p
|| !overlay_arrow_seen
)
17995 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
17996 !NILP (overlay_arrow_string
)))
17998 /* Overlay arrow in window redisplay is a fringe bitmap. */
17999 if (STRINGP (overlay_arrow_string
))
18001 struct glyph_row
*arrow_row
18002 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
18003 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
18004 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
18005 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
18006 struct glyph
*p2
, *end
;
18008 /* Copy the arrow glyphs. */
18009 while (glyph
< arrow_end
)
18012 /* Throw away padding glyphs. */
18014 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
18015 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
18021 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
18026 xassert (INTEGERP (overlay_arrow_string
));
18027 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
18029 overlay_arrow_seen
= 1;
18032 /* Compute pixel dimensions of this line. */
18033 compute_line_metrics (it
);
18035 /* Record whether this row ends inside an ellipsis. */
18036 row
->ends_in_ellipsis_p
18037 = (it
->method
== GET_FROM_DISPLAY_VECTOR
18038 && it
->ellipsis_p
);
18040 /* Save fringe bitmaps in this row. */
18041 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
18042 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
18043 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
18044 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
18046 it
->left_user_fringe_bitmap
= 0;
18047 it
->left_user_fringe_face_id
= 0;
18048 it
->right_user_fringe_bitmap
= 0;
18049 it
->right_user_fringe_face_id
= 0;
18051 /* Maybe set the cursor. */
18052 cvpos
= it
->w
->cursor
.vpos
;
18054 /* In bidi-reordered rows, keep checking for proper cursor
18055 position even if one has been found already, because buffer
18056 positions in such rows change non-linearly with ROW->VPOS,
18057 when a line is continued. One exception: when we are at ZV,
18058 display cursor on the first suitable glyph row, since all
18059 the empty rows after that also have their position set to ZV. */
18060 /* FIXME: Revisit this when glyph ``spilling'' in continuation
18061 lines' rows is implemented for bidi-reordered rows. */
18063 && !MATRIX_ROW (it
->w
->desired_matrix
, cvpos
)->ends_at_zv_p
))
18064 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
18065 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
18066 && cursor_row_p (row
))
18067 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
18069 /* Highlight trailing whitespace. */
18070 if (!NILP (Vshow_trailing_whitespace
))
18071 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
18073 /* Prepare for the next line. This line starts horizontally at (X
18074 HPOS) = (0 0). Vertical positions are incremented. As a
18075 convenience for the caller, IT->glyph_row is set to the next
18077 it
->current_x
= it
->hpos
= 0;
18078 it
->current_y
+= row
->height
;
18079 SET_TEXT_POS (it
->eol_pos
, 0, 0);
18082 /* The next row should by default use the same value of the
18083 reversed_p flag as this one. set_iterator_to_next decides when
18084 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
18085 the flag accordingly. */
18086 if (it
->glyph_row
< MATRIX_BOTTOM_TEXT_ROW (it
->w
->desired_matrix
, it
->w
))
18087 it
->glyph_row
->reversed_p
= row
->reversed_p
;
18088 it
->start
= row
->end
;
18089 return row
->displays_text_p
;
18091 #undef RECORD_MAX_MIN_POS
18094 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction
,
18095 Scurrent_bidi_paragraph_direction
, 0, 1, 0,
18096 doc
: /* Return paragraph direction at point in BUFFER.
18097 Value is either `left-to-right' or `right-to-left'.
18098 If BUFFER is omitted or nil, it defaults to the current buffer.
18100 Paragraph direction determines how the text in the paragraph is displayed.
18101 In left-to-right paragraphs, text begins at the left margin of the window
18102 and the reading direction is generally left to right. In right-to-left
18103 paragraphs, text begins at the right margin and is read from right to left.
18105 See also `bidi-paragraph-direction'. */)
18106 (Lisp_Object buffer
)
18108 struct buffer
*buf
= current_buffer
;
18109 struct buffer
*old
= buf
;
18111 if (! NILP (buffer
))
18113 CHECK_BUFFER (buffer
);
18114 buf
= XBUFFER (buffer
);
18117 if (NILP (BVAR (buf
, bidi_display_reordering
)))
18118 return Qleft_to_right
;
18119 else if (!NILP (BVAR (buf
, bidi_paragraph_direction
)))
18120 return BVAR (buf
, bidi_paragraph_direction
);
18123 /* Determine the direction from buffer text. We could try to
18124 use current_matrix if it is up to date, but this seems fast
18125 enough as it is. */
18126 struct bidi_it itb
;
18127 EMACS_INT pos
= BUF_PT (buf
);
18128 EMACS_INT bytepos
= BUF_PT_BYTE (buf
);
18131 set_buffer_temp (buf
);
18132 /* bidi_paragraph_init finds the base direction of the paragraph
18133 by searching forward from paragraph start. We need the base
18134 direction of the current or _previous_ paragraph, so we need
18135 to make sure we are within that paragraph. To that end, find
18136 the previous non-empty line. */
18137 if (pos
>= ZV
&& pos
> BEGV
)
18140 bytepos
= CHAR_TO_BYTE (pos
);
18142 while ((c
= FETCH_BYTE (bytepos
)) == '\n'
18143 || c
== ' ' || c
== '\t' || c
== '\f')
18145 if (bytepos
<= BEGV_BYTE
)
18150 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos
)))
18153 itb
.bytepos
= bytepos
;
18155 itb
.frame_window_p
= FRAME_WINDOW_P (SELECTED_FRAME ()); /* guesswork */
18157 itb
.separator_limit
= -1;
18158 itb
.paragraph_dir
= NEUTRAL_DIR
;
18160 bidi_paragraph_init (NEUTRAL_DIR
, &itb
, 1);
18161 set_buffer_temp (old
);
18162 switch (itb
.paragraph_dir
)
18165 return Qleft_to_right
;
18168 return Qright_to_left
;
18178 /***********************************************************************
18180 ***********************************************************************/
18182 /* Redisplay the menu bar in the frame for window W.
18184 The menu bar of X frames that don't have X toolkit support is
18185 displayed in a special window W->frame->menu_bar_window.
18187 The menu bar of terminal frames is treated specially as far as
18188 glyph matrices are concerned. Menu bar lines are not part of
18189 windows, so the update is done directly on the frame matrix rows
18190 for the menu bar. */
18193 display_menu_bar (struct window
*w
)
18195 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
18200 /* Don't do all this for graphical frames. */
18202 if (FRAME_W32_P (f
))
18205 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
18211 if (FRAME_NS_P (f
))
18213 #endif /* HAVE_NS */
18215 #ifdef USE_X_TOOLKIT
18216 xassert (!FRAME_WINDOW_P (f
));
18217 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
18218 it
.first_visible_x
= 0;
18219 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
18220 #else /* not USE_X_TOOLKIT */
18221 if (FRAME_WINDOW_P (f
))
18223 /* Menu bar lines are displayed in the desired matrix of the
18224 dummy window menu_bar_window. */
18225 struct window
*menu_w
;
18226 xassert (WINDOWP (f
->menu_bar_window
));
18227 menu_w
= XWINDOW (f
->menu_bar_window
);
18228 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
18230 it
.first_visible_x
= 0;
18231 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
18235 /* This is a TTY frame, i.e. character hpos/vpos are used as
18237 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
18239 it
.first_visible_x
= 0;
18240 it
.last_visible_x
= FRAME_COLS (f
);
18242 #endif /* not USE_X_TOOLKIT */
18244 if (! mode_line_inverse_video
)
18245 /* Force the menu-bar to be displayed in the default face. */
18246 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
18248 /* Clear all rows of the menu bar. */
18249 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
18251 struct glyph_row
*row
= it
.glyph_row
+ i
;
18252 clear_glyph_row (row
);
18253 row
->enabled_p
= 1;
18254 row
->full_width_p
= 1;
18257 /* Display all items of the menu bar. */
18258 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
18259 for (i
= 0; i
< ASIZE (items
); i
+= 4)
18261 Lisp_Object string
;
18263 /* Stop at nil string. */
18264 string
= AREF (items
, i
+ 1);
18268 /* Remember where item was displayed. */
18269 ASET (items
, i
+ 3, make_number (it
.hpos
));
18271 /* Display the item, pad with one space. */
18272 if (it
.current_x
< it
.last_visible_x
)
18273 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
18274 SCHARS (string
) + 1, 0, 0, -1);
18277 /* Fill out the line with spaces. */
18278 if (it
.current_x
< it
.last_visible_x
)
18279 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
18281 /* Compute the total height of the lines. */
18282 compute_line_metrics (&it
);
18287 /***********************************************************************
18289 ***********************************************************************/
18291 /* Redisplay mode lines in the window tree whose root is WINDOW. If
18292 FORCE is non-zero, redisplay mode lines unconditionally.
18293 Otherwise, redisplay only mode lines that are garbaged. Value is
18294 the number of windows whose mode lines were redisplayed. */
18297 redisplay_mode_lines (Lisp_Object window
, int force
)
18301 while (!NILP (window
))
18303 struct window
*w
= XWINDOW (window
);
18305 if (WINDOWP (w
->hchild
))
18306 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
18307 else if (WINDOWP (w
->vchild
))
18308 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
18310 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
18311 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
18313 struct text_pos lpoint
;
18314 struct buffer
*old
= current_buffer
;
18316 /* Set the window's buffer for the mode line display. */
18317 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
18318 set_buffer_internal_1 (XBUFFER (w
->buffer
));
18320 /* Point refers normally to the selected window. For any
18321 other window, set up appropriate value. */
18322 if (!EQ (window
, selected_window
))
18324 struct text_pos pt
;
18326 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
18327 if (CHARPOS (pt
) < BEGV
)
18328 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
18329 else if (CHARPOS (pt
) > (ZV
- 1))
18330 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
18332 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
18335 /* Display mode lines. */
18336 clear_glyph_matrix (w
->desired_matrix
);
18337 if (display_mode_lines (w
))
18340 w
->must_be_updated_p
= 1;
18343 /* Restore old settings. */
18344 set_buffer_internal_1 (old
);
18345 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
18355 /* Display the mode and/or header line of window W. Value is the
18356 sum number of mode lines and header lines displayed. */
18359 display_mode_lines (struct window
*w
)
18361 Lisp_Object old_selected_window
, old_selected_frame
;
18364 old_selected_frame
= selected_frame
;
18365 selected_frame
= w
->frame
;
18366 old_selected_window
= selected_window
;
18367 XSETWINDOW (selected_window
, w
);
18369 /* These will be set while the mode line specs are processed. */
18370 line_number_displayed
= 0;
18371 w
->column_number_displayed
= Qnil
;
18373 if (WINDOW_WANTS_MODELINE_P (w
))
18375 struct window
*sel_w
= XWINDOW (old_selected_window
);
18377 /* Select mode line face based on the real selected window. */
18378 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
18379 BVAR (current_buffer
, mode_line_format
));
18383 if (WINDOW_WANTS_HEADER_LINE_P (w
))
18385 display_mode_line (w
, HEADER_LINE_FACE_ID
,
18386 BVAR (current_buffer
, header_line_format
));
18390 selected_frame
= old_selected_frame
;
18391 selected_window
= old_selected_window
;
18396 /* Display mode or header line of window W. FACE_ID specifies which
18397 line to display; it is either MODE_LINE_FACE_ID or
18398 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
18399 display. Value is the pixel height of the mode/header line
18403 display_mode_line (struct window
*w
, enum face_id face_id
, Lisp_Object format
)
18407 int count
= SPECPDL_INDEX ();
18409 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
18410 /* Don't extend on a previously drawn mode-line.
18411 This may happen if called from pos_visible_p. */
18412 it
.glyph_row
->enabled_p
= 0;
18413 prepare_desired_row (it
.glyph_row
);
18415 it
.glyph_row
->mode_line_p
= 1;
18417 if (! mode_line_inverse_video
)
18418 /* Force the mode-line to be displayed in the default face. */
18419 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
18421 record_unwind_protect (unwind_format_mode_line
,
18422 format_mode_line_unwind_data (NULL
, Qnil
, 0));
18424 mode_line_target
= MODE_LINE_DISPLAY
;
18426 /* Temporarily make frame's keyboard the current kboard so that
18427 kboard-local variables in the mode_line_format will get the right
18429 push_kboard (FRAME_KBOARD (it
.f
));
18430 record_unwind_save_match_data ();
18431 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
18434 unbind_to (count
, Qnil
);
18436 /* Fill up with spaces. */
18437 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
18439 compute_line_metrics (&it
);
18440 it
.glyph_row
->full_width_p
= 1;
18441 it
.glyph_row
->continued_p
= 0;
18442 it
.glyph_row
->truncated_on_left_p
= 0;
18443 it
.glyph_row
->truncated_on_right_p
= 0;
18445 /* Make a 3D mode-line have a shadow at its right end. */
18446 face
= FACE_FROM_ID (it
.f
, face_id
);
18447 extend_face_to_end_of_line (&it
);
18448 if (face
->box
!= FACE_NO_BOX
)
18450 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
18451 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
18452 last
->right_box_line_p
= 1;
18455 return it
.glyph_row
->height
;
18458 /* Move element ELT in LIST to the front of LIST.
18459 Return the updated list. */
18462 move_elt_to_front (Lisp_Object elt
, Lisp_Object list
)
18464 register Lisp_Object tail
, prev
;
18465 register Lisp_Object tem
;
18469 while (CONSP (tail
))
18475 /* Splice out the link TAIL. */
18477 list
= XCDR (tail
);
18479 Fsetcdr (prev
, XCDR (tail
));
18481 /* Now make it the first. */
18482 Fsetcdr (tail
, list
);
18487 tail
= XCDR (tail
);
18491 /* Not found--return unchanged LIST. */
18495 /* Contribute ELT to the mode line for window IT->w. How it
18496 translates into text depends on its data type.
18498 IT describes the display environment in which we display, as usual.
18500 DEPTH is the depth in recursion. It is used to prevent
18501 infinite recursion here.
18503 FIELD_WIDTH is the number of characters the display of ELT should
18504 occupy in the mode line, and PRECISION is the maximum number of
18505 characters to display from ELT's representation. See
18506 display_string for details.
18508 Returns the hpos of the end of the text generated by ELT.
18510 PROPS is a property list to add to any string we encounter.
18512 If RISKY is nonzero, remove (disregard) any properties in any string
18513 we encounter, and ignore :eval and :propertize.
18515 The global variable `mode_line_target' determines whether the
18516 output is passed to `store_mode_line_noprop',
18517 `store_mode_line_string', or `display_string'. */
18520 display_mode_element (struct it
*it
, int depth
, int field_width
, int precision
,
18521 Lisp_Object elt
, Lisp_Object props
, int risky
)
18523 int n
= 0, field
, prec
;
18528 elt
= build_string ("*too-deep*");
18532 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
18536 /* A string: output it and check for %-constructs within it. */
18538 EMACS_INT offset
= 0;
18540 if (SCHARS (elt
) > 0
18541 && (!NILP (props
) || risky
))
18543 Lisp_Object oprops
, aelt
;
18544 oprops
= Ftext_properties_at (make_number (0), elt
);
18546 /* If the starting string's properties are not what
18547 we want, translate the string. Also, if the string
18548 is risky, do that anyway. */
18550 if (NILP (Fequal (props
, oprops
)) || risky
)
18552 /* If the starting string has properties,
18553 merge the specified ones onto the existing ones. */
18554 if (! NILP (oprops
) && !risky
)
18558 oprops
= Fcopy_sequence (oprops
);
18560 while (CONSP (tem
))
18562 oprops
= Fplist_put (oprops
, XCAR (tem
),
18563 XCAR (XCDR (tem
)));
18564 tem
= XCDR (XCDR (tem
));
18569 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
18570 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
18572 /* AELT is what we want. Move it to the front
18573 without consing. */
18575 mode_line_proptrans_alist
18576 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
18582 /* If AELT has the wrong props, it is useless.
18583 so get rid of it. */
18585 mode_line_proptrans_alist
18586 = Fdelq (aelt
, mode_line_proptrans_alist
);
18588 elt
= Fcopy_sequence (elt
);
18589 Fset_text_properties (make_number (0), Flength (elt
),
18591 /* Add this item to mode_line_proptrans_alist. */
18592 mode_line_proptrans_alist
18593 = Fcons (Fcons (elt
, props
),
18594 mode_line_proptrans_alist
);
18595 /* Truncate mode_line_proptrans_alist
18596 to at most 50 elements. */
18597 tem
= Fnthcdr (make_number (50),
18598 mode_line_proptrans_alist
);
18600 XSETCDR (tem
, Qnil
);
18609 prec
= precision
- n
;
18610 switch (mode_line_target
)
18612 case MODE_LINE_NOPROP
:
18613 case MODE_LINE_TITLE
:
18614 n
+= store_mode_line_noprop (SSDATA (elt
), -1, prec
);
18616 case MODE_LINE_STRING
:
18617 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
18619 case MODE_LINE_DISPLAY
:
18620 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
18621 0, prec
, 0, STRING_MULTIBYTE (elt
));
18628 /* Handle the non-literal case. */
18630 while ((precision
<= 0 || n
< precision
)
18631 && SREF (elt
, offset
) != 0
18632 && (mode_line_target
!= MODE_LINE_DISPLAY
18633 || it
->current_x
< it
->last_visible_x
))
18635 EMACS_INT last_offset
= offset
;
18637 /* Advance to end of string or next format specifier. */
18638 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
18641 if (offset
- 1 != last_offset
)
18643 EMACS_INT nchars
, nbytes
;
18645 /* Output to end of string or up to '%'. Field width
18646 is length of string. Don't output more than
18647 PRECISION allows us. */
18650 prec
= c_string_width (SDATA (elt
) + last_offset
,
18651 offset
- last_offset
, precision
- n
,
18654 switch (mode_line_target
)
18656 case MODE_LINE_NOPROP
:
18657 case MODE_LINE_TITLE
:
18658 n
+= store_mode_line_noprop (SSDATA (elt
) + last_offset
, 0, prec
);
18660 case MODE_LINE_STRING
:
18662 EMACS_INT bytepos
= last_offset
;
18663 EMACS_INT charpos
= string_byte_to_char (elt
, bytepos
);
18664 EMACS_INT endpos
= (precision
<= 0
18665 ? string_byte_to_char (elt
, offset
)
18666 : charpos
+ nchars
);
18668 n
+= store_mode_line_string (NULL
,
18669 Fsubstring (elt
, make_number (charpos
),
18670 make_number (endpos
)),
18674 case MODE_LINE_DISPLAY
:
18676 EMACS_INT bytepos
= last_offset
;
18677 EMACS_INT charpos
= string_byte_to_char (elt
, bytepos
);
18679 if (precision
<= 0)
18680 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
18681 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
18683 STRING_MULTIBYTE (elt
));
18688 else /* c == '%' */
18690 EMACS_INT percent_position
= offset
;
18692 /* Get the specified minimum width. Zero means
18695 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
18696 field
= field
* 10 + c
- '0';
18698 /* Don't pad beyond the total padding allowed. */
18699 if (field_width
- n
> 0 && field
> field_width
- n
)
18700 field
= field_width
- n
;
18702 /* Note that either PRECISION <= 0 or N < PRECISION. */
18703 prec
= precision
- n
;
18706 n
+= display_mode_element (it
, depth
, field
, prec
,
18707 Vglobal_mode_string
, props
,
18712 EMACS_INT bytepos
, charpos
;
18714 Lisp_Object string
;
18716 bytepos
= percent_position
;
18717 charpos
= (STRING_MULTIBYTE (elt
)
18718 ? string_byte_to_char (elt
, bytepos
)
18720 spec
= decode_mode_spec (it
->w
, c
, field
, &string
);
18721 multibyte
= STRINGP (string
) && STRING_MULTIBYTE (string
);
18723 switch (mode_line_target
)
18725 case MODE_LINE_NOPROP
:
18726 case MODE_LINE_TITLE
:
18727 n
+= store_mode_line_noprop (spec
, field
, prec
);
18729 case MODE_LINE_STRING
:
18731 int len
= strlen (spec
);
18732 Lisp_Object tem
= make_string (spec
, len
);
18733 props
= Ftext_properties_at (make_number (charpos
), elt
);
18734 /* Should only keep face property in props */
18735 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
18738 case MODE_LINE_DISPLAY
:
18740 int nglyphs_before
, nwritten
;
18742 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
18743 nwritten
= display_string (spec
, string
, elt
,
18748 /* Assign to the glyphs written above the
18749 string where the `%x' came from, position
18753 struct glyph
*glyph
18754 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
18758 for (i
= 0; i
< nwritten
; ++i
)
18760 glyph
[i
].object
= elt
;
18761 glyph
[i
].charpos
= charpos
;
18778 /* A symbol: process the value of the symbol recursively
18779 as if it appeared here directly. Avoid error if symbol void.
18780 Special case: if value of symbol is a string, output the string
18783 register Lisp_Object tem
;
18785 /* If the variable is not marked as risky to set
18786 then its contents are risky to use. */
18787 if (NILP (Fget (elt
, Qrisky_local_variable
)))
18790 tem
= Fboundp (elt
);
18793 tem
= Fsymbol_value (elt
);
18794 /* If value is a string, output that string literally:
18795 don't check for % within it. */
18799 if (!EQ (tem
, elt
))
18801 /* Give up right away for nil or t. */
18811 register Lisp_Object car
, tem
;
18813 /* A cons cell: five distinct cases.
18814 If first element is :eval or :propertize, do something special.
18815 If first element is a string or a cons, process all the elements
18816 and effectively concatenate them.
18817 If first element is a negative number, truncate displaying cdr to
18818 at most that many characters. If positive, pad (with spaces)
18819 to at least that many characters.
18820 If first element is a symbol, process the cadr or caddr recursively
18821 according to whether the symbol's value is non-nil or nil. */
18823 if (EQ (car
, QCeval
))
18825 /* An element of the form (:eval FORM) means evaluate FORM
18826 and use the result as mode line elements. */
18831 if (CONSP (XCDR (elt
)))
18834 spec
= safe_eval (XCAR (XCDR (elt
)));
18835 n
+= display_mode_element (it
, depth
, field_width
- n
,
18836 precision
- n
, spec
, props
,
18840 else if (EQ (car
, QCpropertize
))
18842 /* An element of the form (:propertize ELT PROPS...)
18843 means display ELT but applying properties PROPS. */
18848 if (CONSP (XCDR (elt
)))
18849 n
+= display_mode_element (it
, depth
, field_width
- n
,
18850 precision
- n
, XCAR (XCDR (elt
)),
18851 XCDR (XCDR (elt
)), risky
);
18853 else if (SYMBOLP (car
))
18855 tem
= Fboundp (car
);
18859 /* elt is now the cdr, and we know it is a cons cell.
18860 Use its car if CAR has a non-nil value. */
18863 tem
= Fsymbol_value (car
);
18870 /* Symbol's value is nil (or symbol is unbound)
18871 Get the cddr of the original list
18872 and if possible find the caddr and use that. */
18876 else if (!CONSP (elt
))
18881 else if (INTEGERP (car
))
18883 register int lim
= XINT (car
);
18887 /* Negative int means reduce maximum width. */
18888 if (precision
<= 0)
18891 precision
= min (precision
, -lim
);
18895 /* Padding specified. Don't let it be more than
18896 current maximum. */
18898 lim
= min (precision
, lim
);
18900 /* If that's more padding than already wanted, queue it.
18901 But don't reduce padding already specified even if
18902 that is beyond the current truncation point. */
18903 field_width
= max (lim
, field_width
);
18907 else if (STRINGP (car
) || CONSP (car
))
18909 Lisp_Object halftail
= elt
;
18913 && (precision
<= 0 || n
< precision
))
18915 n
+= display_mode_element (it
, depth
,
18916 /* Do padding only after the last
18917 element in the list. */
18918 (! CONSP (XCDR (elt
))
18921 precision
- n
, XCAR (elt
),
18925 if ((len
& 1) == 0)
18926 halftail
= XCDR (halftail
);
18927 /* Check for cycle. */
18928 if (EQ (halftail
, elt
))
18937 elt
= build_string ("*invalid*");
18941 /* Pad to FIELD_WIDTH. */
18942 if (field_width
> 0 && n
< field_width
)
18944 switch (mode_line_target
)
18946 case MODE_LINE_NOPROP
:
18947 case MODE_LINE_TITLE
:
18948 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
18950 case MODE_LINE_STRING
:
18951 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
18953 case MODE_LINE_DISPLAY
:
18954 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
18963 /* Store a mode-line string element in mode_line_string_list.
18965 If STRING is non-null, display that C string. Otherwise, the Lisp
18966 string LISP_STRING is displayed.
18968 FIELD_WIDTH is the minimum number of output glyphs to produce.
18969 If STRING has fewer characters than FIELD_WIDTH, pad to the right
18970 with spaces. FIELD_WIDTH <= 0 means don't pad.
18972 PRECISION is the maximum number of characters to output from
18973 STRING. PRECISION <= 0 means don't truncate the string.
18975 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
18976 properties to the string.
18978 PROPS are the properties to add to the string.
18979 The mode_line_string_face face property is always added to the string.
18983 store_mode_line_string (const char *string
, Lisp_Object lisp_string
, int copy_string
,
18984 int field_width
, int precision
, Lisp_Object props
)
18989 if (string
!= NULL
)
18991 len
= strlen (string
);
18992 if (precision
> 0 && len
> precision
)
18994 lisp_string
= make_string (string
, len
);
18996 props
= mode_line_string_face_prop
;
18997 else if (!NILP (mode_line_string_face
))
18999 Lisp_Object face
= Fplist_get (props
, Qface
);
19000 props
= Fcopy_sequence (props
);
19002 face
= mode_line_string_face
;
19004 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
19005 props
= Fplist_put (props
, Qface
, face
);
19007 Fadd_text_properties (make_number (0), make_number (len
),
19008 props
, lisp_string
);
19012 len
= XFASTINT (Flength (lisp_string
));
19013 if (precision
> 0 && len
> precision
)
19016 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
19019 if (!NILP (mode_line_string_face
))
19023 props
= Ftext_properties_at (make_number (0), lisp_string
);
19024 face
= Fplist_get (props
, Qface
);
19026 face
= mode_line_string_face
;
19028 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
19029 props
= Fcons (Qface
, Fcons (face
, Qnil
));
19031 lisp_string
= Fcopy_sequence (lisp_string
);
19034 Fadd_text_properties (make_number (0), make_number (len
),
19035 props
, lisp_string
);
19040 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
19044 if (field_width
> len
)
19046 field_width
-= len
;
19047 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
19049 Fadd_text_properties (make_number (0), make_number (field_width
),
19050 props
, lisp_string
);
19051 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
19059 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
19061 doc
: /* Format a string out of a mode line format specification.
19062 First arg FORMAT specifies the mode line format (see `mode-line-format'
19063 for details) to use.
19065 By default, the format is evaluated for the currently selected window.
19067 Optional second arg FACE specifies the face property to put on all
19068 characters for which no face is specified. The value nil means the
19069 default face. The value t means whatever face the window's mode line
19070 currently uses (either `mode-line' or `mode-line-inactive',
19071 depending on whether the window is the selected window or not).
19072 An integer value means the value string has no text
19075 Optional third and fourth args WINDOW and BUFFER specify the window
19076 and buffer to use as the context for the formatting (defaults
19077 are the selected window and the WINDOW's buffer). */)
19078 (Lisp_Object format
, Lisp_Object face
,
19079 Lisp_Object window
, Lisp_Object buffer
)
19084 struct buffer
*old_buffer
= NULL
;
19086 int no_props
= INTEGERP (face
);
19087 int count
= SPECPDL_INDEX ();
19089 int string_start
= 0;
19092 window
= selected_window
;
19093 CHECK_WINDOW (window
);
19094 w
= XWINDOW (window
);
19097 buffer
= w
->buffer
;
19098 CHECK_BUFFER (buffer
);
19100 /* Make formatting the modeline a non-op when noninteractive, otherwise
19101 there will be problems later caused by a partially initialized frame. */
19102 if (NILP (format
) || noninteractive
)
19103 return empty_unibyte_string
;
19108 face_id
= (NILP (face
) || EQ (face
, Qdefault
)) ? DEFAULT_FACE_ID
19109 : EQ (face
, Qt
) ? (EQ (window
, selected_window
)
19110 ? MODE_LINE_FACE_ID
: MODE_LINE_INACTIVE_FACE_ID
)
19111 : EQ (face
, Qmode_line
) ? MODE_LINE_FACE_ID
19112 : EQ (face
, Qmode_line_inactive
) ? MODE_LINE_INACTIVE_FACE_ID
19113 : EQ (face
, Qheader_line
) ? HEADER_LINE_FACE_ID
19114 : EQ (face
, Qtool_bar
) ? TOOL_BAR_FACE_ID
19117 if (XBUFFER (buffer
) != current_buffer
)
19118 old_buffer
= current_buffer
;
19120 /* Save things including mode_line_proptrans_alist,
19121 and set that to nil so that we don't alter the outer value. */
19122 record_unwind_protect (unwind_format_mode_line
,
19123 format_mode_line_unwind_data
19124 (old_buffer
, selected_window
, 1));
19125 mode_line_proptrans_alist
= Qnil
;
19127 Fselect_window (window
, Qt
);
19129 set_buffer_internal_1 (XBUFFER (buffer
));
19131 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
19135 mode_line_target
= MODE_LINE_NOPROP
;
19136 mode_line_string_face_prop
= Qnil
;
19137 mode_line_string_list
= Qnil
;
19138 string_start
= MODE_LINE_NOPROP_LEN (0);
19142 mode_line_target
= MODE_LINE_STRING
;
19143 mode_line_string_list
= Qnil
;
19144 mode_line_string_face
= face
;
19145 mode_line_string_face_prop
19146 = (NILP (face
) ? Qnil
: Fcons (Qface
, Fcons (face
, Qnil
)));
19149 push_kboard (FRAME_KBOARD (it
.f
));
19150 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
19155 len
= MODE_LINE_NOPROP_LEN (string_start
);
19156 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
19160 mode_line_string_list
= Fnreverse (mode_line_string_list
);
19161 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
19162 empty_unibyte_string
);
19165 unbind_to (count
, Qnil
);
19169 /* Write a null-terminated, right justified decimal representation of
19170 the positive integer D to BUF using a minimal field width WIDTH. */
19173 pint2str (register char *buf
, register int width
, register EMACS_INT d
)
19175 register char *p
= buf
;
19183 *p
++ = d
% 10 + '0';
19188 for (width
-= (int) (p
- buf
); width
> 0; --width
)
19199 /* Write a null-terminated, right justified decimal and "human
19200 readable" representation of the nonnegative integer D to BUF using
19201 a minimal field width WIDTH. D should be smaller than 999.5e24. */
19203 static const char power_letter
[] =
19217 pint2hrstr (char *buf
, int width
, EMACS_INT d
)
19219 /* We aim to represent the nonnegative integer D as
19220 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
19221 EMACS_INT quotient
= d
;
19223 /* -1 means: do not use TENTHS. */
19227 /* Length of QUOTIENT.TENTHS as a string. */
19233 if (1000 <= quotient
)
19235 /* Scale to the appropriate EXPONENT. */
19238 remainder
= quotient
% 1000;
19242 while (1000 <= quotient
);
19244 /* Round to nearest and decide whether to use TENTHS or not. */
19247 tenths
= remainder
/ 100;
19248 if (50 <= remainder
% 100)
19255 if (quotient
== 10)
19263 if (500 <= remainder
)
19265 if (quotient
< 999)
19276 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
19277 if (tenths
== -1 && quotient
<= 99)
19284 p
= psuffix
= buf
+ max (width
, length
);
19286 /* Print EXPONENT. */
19287 *psuffix
++ = power_letter
[exponent
];
19290 /* Print TENTHS. */
19293 *--p
= '0' + tenths
;
19297 /* Print QUOTIENT. */
19300 int digit
= quotient
% 10;
19301 *--p
= '0' + digit
;
19303 while ((quotient
/= 10) != 0);
19305 /* Print leading spaces. */
19310 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
19311 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
19312 type of CODING_SYSTEM. Return updated pointer into BUF. */
19314 static unsigned char invalid_eol_type
[] = "(*invalid*)";
19317 decode_mode_spec_coding (Lisp_Object coding_system
, register char *buf
, int eol_flag
)
19320 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
19321 const unsigned char *eol_str
;
19323 /* The EOL conversion we are using. */
19324 Lisp_Object eoltype
;
19326 val
= CODING_SYSTEM_SPEC (coding_system
);
19329 if (!VECTORP (val
)) /* Not yet decided. */
19334 eoltype
= eol_mnemonic_undecided
;
19335 /* Don't mention EOL conversion if it isn't decided. */
19340 Lisp_Object eolvalue
;
19342 attrs
= AREF (val
, 0);
19343 eolvalue
= AREF (val
, 2);
19346 *buf
++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs
));
19350 /* The EOL conversion that is normal on this system. */
19352 if (NILP (eolvalue
)) /* Not yet decided. */
19353 eoltype
= eol_mnemonic_undecided
;
19354 else if (VECTORP (eolvalue
)) /* Not yet decided. */
19355 eoltype
= eol_mnemonic_undecided
;
19356 else /* eolvalue is Qunix, Qdos, or Qmac. */
19357 eoltype
= (EQ (eolvalue
, Qunix
)
19358 ? eol_mnemonic_unix
19359 : (EQ (eolvalue
, Qdos
) == 1
19360 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
19366 /* Mention the EOL conversion if it is not the usual one. */
19367 if (STRINGP (eoltype
))
19369 eol_str
= SDATA (eoltype
);
19370 eol_str_len
= SBYTES (eoltype
);
19372 else if (CHARACTERP (eoltype
))
19374 unsigned char *tmp
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
);
19375 int c
= XFASTINT (eoltype
);
19376 eol_str_len
= CHAR_STRING (c
, tmp
);
19381 eol_str
= invalid_eol_type
;
19382 eol_str_len
= sizeof (invalid_eol_type
) - 1;
19384 memcpy (buf
, eol_str
, eol_str_len
);
19385 buf
+= eol_str_len
;
19391 /* Return a string for the output of a mode line %-spec for window W,
19392 generated by character C. FIELD_WIDTH > 0 means pad the string
19393 returned with spaces to that value. Return a Lisp string in
19394 *STRING if the resulting string is taken from that Lisp string.
19396 Note we operate on the current buffer for most purposes,
19397 the exception being w->base_line_pos. */
19399 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
19401 static const char *
19402 decode_mode_spec (struct window
*w
, register int c
, int field_width
,
19403 Lisp_Object
*string
)
19406 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
19407 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
19408 struct buffer
*b
= current_buffer
;
19416 if (!NILP (BVAR (b
, read_only
)))
19418 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
19423 /* This differs from %* only for a modified read-only buffer. */
19424 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
19426 if (!NILP (BVAR (b
, read_only
)))
19431 /* This differs from %* in ignoring read-only-ness. */
19432 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
19444 if (command_loop_level
> 5)
19446 p
= decode_mode_spec_buf
;
19447 for (i
= 0; i
< command_loop_level
; i
++)
19450 return decode_mode_spec_buf
;
19458 if (command_loop_level
> 5)
19460 p
= decode_mode_spec_buf
;
19461 for (i
= 0; i
< command_loop_level
; i
++)
19464 return decode_mode_spec_buf
;
19471 /* Let lots_of_dashes be a string of infinite length. */
19472 if (mode_line_target
== MODE_LINE_NOPROP
||
19473 mode_line_target
== MODE_LINE_STRING
)
19475 if (field_width
<= 0
19476 || field_width
> sizeof (lots_of_dashes
))
19478 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
19479 decode_mode_spec_buf
[i
] = '-';
19480 decode_mode_spec_buf
[i
] = '\0';
19481 return decode_mode_spec_buf
;
19484 return lots_of_dashes
;
19488 obj
= BVAR (b
, name
);
19492 /* %c and %l are ignored in `frame-title-format'.
19493 (In redisplay_internal, the frame title is drawn _before_ the
19494 windows are updated, so the stuff which depends on actual
19495 window contents (such as %l) may fail to render properly, or
19496 even crash emacs.) */
19497 if (mode_line_target
== MODE_LINE_TITLE
)
19501 EMACS_INT col
= current_column ();
19502 w
->column_number_displayed
= make_number (col
);
19503 pint2str (decode_mode_spec_buf
, field_width
, col
);
19504 return decode_mode_spec_buf
;
19508 #ifndef SYSTEM_MALLOC
19510 if (NILP (Vmemory_full
))
19513 return "!MEM FULL! ";
19520 /* %F displays the frame name. */
19521 if (!NILP (f
->title
))
19522 return SSDATA (f
->title
);
19523 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
19524 return SSDATA (f
->name
);
19528 obj
= BVAR (b
, filename
);
19533 EMACS_INT size
= ZV
- BEGV
;
19534 pint2str (decode_mode_spec_buf
, field_width
, size
);
19535 return decode_mode_spec_buf
;
19540 EMACS_INT size
= ZV
- BEGV
;
19541 pint2hrstr (decode_mode_spec_buf
, field_width
, size
);
19542 return decode_mode_spec_buf
;
19547 EMACS_INT startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
19548 EMACS_INT topline
, nlines
, height
;
19551 /* %c and %l are ignored in `frame-title-format'. */
19552 if (mode_line_target
== MODE_LINE_TITLE
)
19555 startpos
= XMARKER (w
->start
)->charpos
;
19556 startpos_byte
= marker_byte_position (w
->start
);
19557 height
= WINDOW_TOTAL_LINES (w
);
19559 /* If we decided that this buffer isn't suitable for line numbers,
19560 don't forget that too fast. */
19561 if (EQ (w
->base_line_pos
, w
->buffer
))
19563 /* But do forget it, if the window shows a different buffer now. */
19564 else if (BUFFERP (w
->base_line_pos
))
19565 w
->base_line_pos
= Qnil
;
19567 /* If the buffer is very big, don't waste time. */
19568 if (INTEGERP (Vline_number_display_limit
)
19569 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
19571 w
->base_line_pos
= Qnil
;
19572 w
->base_line_number
= Qnil
;
19576 if (INTEGERP (w
->base_line_number
)
19577 && INTEGERP (w
->base_line_pos
)
19578 && XFASTINT (w
->base_line_pos
) <= startpos
)
19580 line
= XFASTINT (w
->base_line_number
);
19581 linepos
= XFASTINT (w
->base_line_pos
);
19582 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
19587 linepos
= BUF_BEGV (b
);
19588 linepos_byte
= BUF_BEGV_BYTE (b
);
19591 /* Count lines from base line to window start position. */
19592 nlines
= display_count_lines (linepos_byte
,
19596 topline
= nlines
+ line
;
19598 /* Determine a new base line, if the old one is too close
19599 or too far away, or if we did not have one.
19600 "Too close" means it's plausible a scroll-down would
19601 go back past it. */
19602 if (startpos
== BUF_BEGV (b
))
19604 w
->base_line_number
= make_number (topline
);
19605 w
->base_line_pos
= make_number (BUF_BEGV (b
));
19607 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
19608 || linepos
== BUF_BEGV (b
))
19610 EMACS_INT limit
= BUF_BEGV (b
);
19611 EMACS_INT limit_byte
= BUF_BEGV_BYTE (b
);
19612 EMACS_INT position
;
19613 EMACS_INT distance
=
19614 (height
* 2 + 30) * line_number_display_limit_width
;
19616 if (startpos
- distance
> limit
)
19618 limit
= startpos
- distance
;
19619 limit_byte
= CHAR_TO_BYTE (limit
);
19622 nlines
= display_count_lines (startpos_byte
,
19624 - (height
* 2 + 30),
19626 /* If we couldn't find the lines we wanted within
19627 line_number_display_limit_width chars per line,
19628 give up on line numbers for this window. */
19629 if (position
== limit_byte
&& limit
== startpos
- distance
)
19631 w
->base_line_pos
= w
->buffer
;
19632 w
->base_line_number
= Qnil
;
19636 w
->base_line_number
= make_number (topline
- nlines
);
19637 w
->base_line_pos
= make_number (BYTE_TO_CHAR (position
));
19640 /* Now count lines from the start pos to point. */
19641 nlines
= display_count_lines (startpos_byte
,
19642 PT_BYTE
, PT
, &junk
);
19644 /* Record that we did display the line number. */
19645 line_number_displayed
= 1;
19647 /* Make the string to show. */
19648 pint2str (decode_mode_spec_buf
, field_width
, topline
+ nlines
);
19649 return decode_mode_spec_buf
;
19652 char* p
= decode_mode_spec_buf
;
19653 int pad
= field_width
- 2;
19659 return decode_mode_spec_buf
;
19665 obj
= BVAR (b
, mode_name
);
19669 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
19675 EMACS_INT pos
= marker_position (w
->start
);
19676 EMACS_INT total
= BUF_ZV (b
) - BUF_BEGV (b
);
19678 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
19680 if (pos
<= BUF_BEGV (b
))
19685 else if (pos
<= BUF_BEGV (b
))
19689 if (total
> 1000000)
19690 /* Do it differently for a large value, to avoid overflow. */
19691 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
19693 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
19694 /* We can't normally display a 3-digit number,
19695 so get us a 2-digit number that is close. */
19698 sprintf (decode_mode_spec_buf
, "%2"pI
"d%%", total
);
19699 return decode_mode_spec_buf
;
19703 /* Display percentage of size above the bottom of the screen. */
19706 EMACS_INT toppos
= marker_position (w
->start
);
19707 EMACS_INT botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
19708 EMACS_INT total
= BUF_ZV (b
) - BUF_BEGV (b
);
19710 if (botpos
>= BUF_ZV (b
))
19712 if (toppos
<= BUF_BEGV (b
))
19719 if (total
> 1000000)
19720 /* Do it differently for a large value, to avoid overflow. */
19721 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
19723 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
19724 /* We can't normally display a 3-digit number,
19725 so get us a 2-digit number that is close. */
19728 if (toppos
<= BUF_BEGV (b
))
19729 sprintf (decode_mode_spec_buf
, "Top%2"pI
"d%%", total
);
19731 sprintf (decode_mode_spec_buf
, "%2"pI
"d%%", total
);
19732 return decode_mode_spec_buf
;
19737 /* status of process */
19738 obj
= Fget_buffer_process (Fcurrent_buffer ());
19740 return "no process";
19742 obj
= Fsymbol_name (Fprocess_status (obj
));
19748 int count
= inhibit_garbage_collection ();
19749 Lisp_Object val
= call1 (intern ("file-remote-p"),
19750 BVAR (current_buffer
, directory
));
19751 unbind_to (count
, Qnil
);
19759 case 't': /* indicate TEXT or BINARY */
19763 /* coding-system (not including end-of-line format) */
19765 /* coding-system (including end-of-line type) */
19767 int eol_flag
= (c
== 'Z');
19768 char *p
= decode_mode_spec_buf
;
19770 if (! FRAME_WINDOW_P (f
))
19772 /* No need to mention EOL here--the terminal never needs
19773 to do EOL conversion. */
19774 p
= decode_mode_spec_coding (CODING_ID_NAME
19775 (FRAME_KEYBOARD_CODING (f
)->id
),
19777 p
= decode_mode_spec_coding (CODING_ID_NAME
19778 (FRAME_TERMINAL_CODING (f
)->id
),
19781 p
= decode_mode_spec_coding (BVAR (b
, buffer_file_coding_system
),
19784 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
19785 #ifdef subprocesses
19786 obj
= Fget_buffer_process (Fcurrent_buffer ());
19787 if (PROCESSP (obj
))
19789 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
19791 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
19794 #endif /* subprocesses */
19797 return decode_mode_spec_buf
;
19804 return SSDATA (obj
);
19811 /* Count up to COUNT lines starting from START_BYTE.
19812 But don't go beyond LIMIT_BYTE.
19813 Return the number of lines thus found (always nonnegative).
19815 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
19818 display_count_lines (EMACS_INT start_byte
,
19819 EMACS_INT limit_byte
, EMACS_INT count
,
19820 EMACS_INT
*byte_pos_ptr
)
19822 register unsigned char *cursor
;
19823 unsigned char *base
;
19825 register EMACS_INT ceiling
;
19826 register unsigned char *ceiling_addr
;
19827 EMACS_INT orig_count
= count
;
19829 /* If we are not in selective display mode,
19830 check only for newlines. */
19831 int selective_display
= (!NILP (BVAR (current_buffer
, selective_display
))
19832 && !INTEGERP (BVAR (current_buffer
, selective_display
)));
19836 while (start_byte
< limit_byte
)
19838 ceiling
= BUFFER_CEILING_OF (start_byte
);
19839 ceiling
= min (limit_byte
- 1, ceiling
);
19840 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
19841 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
19844 if (selective_display
)
19845 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
19848 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
19851 if (cursor
!= ceiling_addr
)
19855 start_byte
+= cursor
- base
+ 1;
19856 *byte_pos_ptr
= start_byte
;
19860 if (++cursor
== ceiling_addr
)
19866 start_byte
+= cursor
- base
;
19871 while (start_byte
> limit_byte
)
19873 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
19874 ceiling
= max (limit_byte
, ceiling
);
19875 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
19876 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
19879 if (selective_display
)
19880 while (--cursor
!= ceiling_addr
19881 && *cursor
!= '\n' && *cursor
!= 015)
19884 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
19887 if (cursor
!= ceiling_addr
)
19891 start_byte
+= cursor
- base
+ 1;
19892 *byte_pos_ptr
= start_byte
;
19893 /* When scanning backwards, we should
19894 not count the newline posterior to which we stop. */
19895 return - orig_count
- 1;
19901 /* Here we add 1 to compensate for the last decrement
19902 of CURSOR, which took it past the valid range. */
19903 start_byte
+= cursor
- base
+ 1;
19907 *byte_pos_ptr
= limit_byte
;
19910 return - orig_count
+ count
;
19911 return orig_count
- count
;
19917 /***********************************************************************
19919 ***********************************************************************/
19921 /* Display a NUL-terminated string, starting with index START.
19923 If STRING is non-null, display that C string. Otherwise, the Lisp
19924 string LISP_STRING is displayed. There's a case that STRING is
19925 non-null and LISP_STRING is not nil. It means STRING is a string
19926 data of LISP_STRING. In that case, we display LISP_STRING while
19927 ignoring its text properties.
19929 If FACE_STRING is not nil, FACE_STRING_POS is a position in
19930 FACE_STRING. Display STRING or LISP_STRING with the face at
19931 FACE_STRING_POS in FACE_STRING:
19933 Display the string in the environment given by IT, but use the
19934 standard display table, temporarily.
19936 FIELD_WIDTH is the minimum number of output glyphs to produce.
19937 If STRING has fewer characters than FIELD_WIDTH, pad to the right
19938 with spaces. If STRING has more characters, more than FIELD_WIDTH
19939 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
19941 PRECISION is the maximum number of characters to output from
19942 STRING. PRECISION < 0 means don't truncate the string.
19944 This is roughly equivalent to printf format specifiers:
19946 FIELD_WIDTH PRECISION PRINTF
19947 ----------------------------------------
19953 MULTIBYTE zero means do not display multibyte chars, > 0 means do
19954 display them, and < 0 means obey the current buffer's value of
19955 enable_multibyte_characters.
19957 Value is the number of columns displayed. */
19960 display_string (const char *string
, Lisp_Object lisp_string
, Lisp_Object face_string
,
19961 EMACS_INT face_string_pos
, EMACS_INT start
, struct it
*it
,
19962 int field_width
, int precision
, int max_x
, int multibyte
)
19964 int hpos_at_start
= it
->hpos
;
19965 int saved_face_id
= it
->face_id
;
19966 struct glyph_row
*row
= it
->glyph_row
;
19968 /* Initialize the iterator IT for iteration over STRING beginning
19969 with index START. */
19970 reseat_to_string (it
, NILP (lisp_string
) ? string
: NULL
, lisp_string
, start
,
19971 precision
, field_width
, multibyte
);
19972 if (string
&& STRINGP (lisp_string
))
19973 /* LISP_STRING is the one returned by decode_mode_spec. We should
19974 ignore its text properties. */
19975 it
->stop_charpos
= -1;
19977 /* If displaying STRING, set up the face of the iterator
19978 from LISP_STRING, if that's given. */
19979 if (STRINGP (face_string
))
19985 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
19986 0, it
->region_beg_charpos
,
19987 it
->region_end_charpos
,
19988 &endptr
, it
->base_face_id
, 0);
19989 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
19990 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
19993 /* Set max_x to the maximum allowed X position. Don't let it go
19994 beyond the right edge of the window. */
19996 max_x
= it
->last_visible_x
;
19998 max_x
= min (max_x
, it
->last_visible_x
);
20000 /* Skip over display elements that are not visible. because IT->w is
20002 if (it
->current_x
< it
->first_visible_x
)
20003 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
20004 MOVE_TO_POS
| MOVE_TO_X
);
20006 row
->ascent
= it
->max_ascent
;
20007 row
->height
= it
->max_ascent
+ it
->max_descent
;
20008 row
->phys_ascent
= it
->max_phys_ascent
;
20009 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
20010 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
20012 /* This condition is for the case that we are called with current_x
20013 past last_visible_x. */
20014 while (it
->current_x
< max_x
)
20016 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
20018 /* Get the next display element. */
20019 if (!get_next_display_element (it
))
20022 /* Produce glyphs. */
20023 x_before
= it
->current_x
;
20024 n_glyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
20025 PRODUCE_GLYPHS (it
);
20027 nglyphs
= it
->glyph_row
->used
[TEXT_AREA
] - n_glyphs_before
;
20030 while (i
< nglyphs
)
20032 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
20034 if (it
->line_wrap
!= TRUNCATE
20035 && x
+ glyph
->pixel_width
> max_x
)
20037 /* End of continued line or max_x reached. */
20038 if (CHAR_GLYPH_PADDING_P (*glyph
))
20040 /* A wide character is unbreakable. */
20041 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
20042 it
->current_x
= x_before
;
20046 it
->glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
20051 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
20053 /* Glyph is at least partially visible. */
20055 if (x
< it
->first_visible_x
)
20056 it
->glyph_row
->x
= x
- it
->first_visible_x
;
20060 /* Glyph is off the left margin of the display area.
20061 Should not happen. */
20065 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
20066 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
20067 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
20068 row
->phys_height
= max (row
->phys_height
,
20069 it
->max_phys_ascent
+ it
->max_phys_descent
);
20070 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
20071 it
->max_extra_line_spacing
);
20072 x
+= glyph
->pixel_width
;
20076 /* Stop if max_x reached. */
20080 /* Stop at line ends. */
20081 if (ITERATOR_AT_END_OF_LINE_P (it
))
20083 it
->continuation_lines_width
= 0;
20087 set_iterator_to_next (it
, 1);
20089 /* Stop if truncating at the right edge. */
20090 if (it
->line_wrap
== TRUNCATE
20091 && it
->current_x
>= it
->last_visible_x
)
20093 /* Add truncation mark, but don't do it if the line is
20094 truncated at a padding space. */
20095 if (IT_CHARPOS (*it
) < it
->string_nchars
)
20097 if (!FRAME_WINDOW_P (it
->f
))
20101 if (it
->current_x
> it
->last_visible_x
)
20103 for (ii
= row
->used
[TEXT_AREA
] - 1; ii
> 0; --ii
)
20104 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
20106 for (n
= row
->used
[TEXT_AREA
]; ii
< n
; ++ii
)
20108 row
->used
[TEXT_AREA
] = ii
;
20109 produce_special_glyphs (it
, IT_TRUNCATION
);
20112 produce_special_glyphs (it
, IT_TRUNCATION
);
20114 it
->glyph_row
->truncated_on_right_p
= 1;
20120 /* Maybe insert a truncation at the left. */
20121 if (it
->first_visible_x
20122 && IT_CHARPOS (*it
) > 0)
20124 if (!FRAME_WINDOW_P (it
->f
))
20125 insert_left_trunc_glyphs (it
);
20126 it
->glyph_row
->truncated_on_left_p
= 1;
20129 it
->face_id
= saved_face_id
;
20131 /* Value is number of columns displayed. */
20132 return it
->hpos
- hpos_at_start
;
20137 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
20138 appears as an element of LIST or as the car of an element of LIST.
20139 If PROPVAL is a list, compare each element against LIST in that
20140 way, and return 1/2 if any element of PROPVAL is found in LIST.
20141 Otherwise return 0. This function cannot quit.
20142 The return value is 2 if the text is invisible but with an ellipsis
20143 and 1 if it's invisible and without an ellipsis. */
20146 invisible_p (register Lisp_Object propval
, Lisp_Object list
)
20148 register Lisp_Object tail
, proptail
;
20150 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
20152 register Lisp_Object tem
;
20154 if (EQ (propval
, tem
))
20156 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
20157 return NILP (XCDR (tem
)) ? 1 : 2;
20160 if (CONSP (propval
))
20162 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
20164 Lisp_Object propelt
;
20165 propelt
= XCAR (proptail
);
20166 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
20168 register Lisp_Object tem
;
20170 if (EQ (propelt
, tem
))
20172 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
20173 return NILP (XCDR (tem
)) ? 1 : 2;
20181 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
20182 doc
: /* Non-nil if the property makes the text invisible.
20183 POS-OR-PROP can be a marker or number, in which case it is taken to be
20184 a position in the current buffer and the value of the `invisible' property
20185 is checked; or it can be some other value, which is then presumed to be the
20186 value of the `invisible' property of the text of interest.
20187 The non-nil value returned can be t for truly invisible text or something
20188 else if the text is replaced by an ellipsis. */)
20189 (Lisp_Object pos_or_prop
)
20192 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
20193 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
20195 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
20196 return (invis
== 0 ? Qnil
20198 : make_number (invis
));
20201 /* Calculate a width or height in pixels from a specification using
20202 the following elements:
20205 NUM - a (fractional) multiple of the default font width/height
20206 (NUM) - specifies exactly NUM pixels
20207 UNIT - a fixed number of pixels, see below.
20208 ELEMENT - size of a display element in pixels, see below.
20209 (NUM . SPEC) - equals NUM * SPEC
20210 (+ SPEC SPEC ...) - add pixel values
20211 (- SPEC SPEC ...) - subtract pixel values
20212 (- SPEC) - negate pixel value
20215 INT or FLOAT - a number constant
20216 SYMBOL - use symbol's (buffer local) variable binding.
20219 in - pixels per inch *)
20220 mm - pixels per 1/1000 meter *)
20221 cm - pixels per 1/100 meter *)
20222 width - width of current font in pixels.
20223 height - height of current font in pixels.
20225 *) using the ratio(s) defined in display-pixels-per-inch.
20229 left-fringe - left fringe width in pixels
20230 right-fringe - right fringe width in pixels
20232 left-margin - left margin width in pixels
20233 right-margin - right margin width in pixels
20235 scroll-bar - scroll-bar area width in pixels
20239 Pixels corresponding to 5 inches:
20242 Total width of non-text areas on left side of window (if scroll-bar is on left):
20243 '(space :width (+ left-fringe left-margin scroll-bar))
20245 Align to first text column (in header line):
20246 '(space :align-to 0)
20248 Align to middle of text area minus half the width of variable `my-image'
20249 containing a loaded image:
20250 '(space :align-to (0.5 . (- text my-image)))
20252 Width of left margin minus width of 1 character in the default font:
20253 '(space :width (- left-margin 1))
20255 Width of left margin minus width of 2 characters in the current font:
20256 '(space :width (- left-margin (2 . width)))
20258 Center 1 character over left-margin (in header line):
20259 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
20261 Different ways to express width of left fringe plus left margin minus one pixel:
20262 '(space :width (- (+ left-fringe left-margin) (1)))
20263 '(space :width (+ left-fringe left-margin (- (1))))
20264 '(space :width (+ left-fringe left-margin (-1)))
20268 #define NUMVAL(X) \
20269 ((INTEGERP (X) || FLOATP (X)) \
20274 calc_pixel_width_or_height (double *res
, struct it
*it
, Lisp_Object prop
,
20275 struct font
*font
, int width_p
, int *align_to
)
20279 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
20280 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
20283 return OK_PIXELS (0);
20285 xassert (FRAME_LIVE_P (it
->f
));
20287 if (SYMBOLP (prop
))
20289 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
20291 char *unit
= SSDATA (SYMBOL_NAME (prop
));
20293 if (unit
[0] == 'i' && unit
[1] == 'n')
20295 else if (unit
[0] == 'm' && unit
[1] == 'm')
20297 else if (unit
[0] == 'c' && unit
[1] == 'm')
20304 #ifdef HAVE_WINDOW_SYSTEM
20305 if (FRAME_WINDOW_P (it
->f
)
20307 ? FRAME_X_DISPLAY_INFO (it
->f
)->resx
20308 : FRAME_X_DISPLAY_INFO (it
->f
)->resy
),
20310 return OK_PIXELS (ppi
/ pixels
);
20313 if ((ppi
= NUMVAL (Vdisplay_pixels_per_inch
), ppi
> 0)
20314 || (CONSP (Vdisplay_pixels_per_inch
)
20316 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch
))
20317 : NUMVAL (XCDR (Vdisplay_pixels_per_inch
))),
20319 return OK_PIXELS (ppi
/ pixels
);
20325 #ifdef HAVE_WINDOW_SYSTEM
20326 if (EQ (prop
, Qheight
))
20327 return OK_PIXELS (font
? FONT_HEIGHT (font
) : FRAME_LINE_HEIGHT (it
->f
));
20328 if (EQ (prop
, Qwidth
))
20329 return OK_PIXELS (font
? FONT_WIDTH (font
) : FRAME_COLUMN_WIDTH (it
->f
));
20331 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
20332 return OK_PIXELS (1);
20335 if (EQ (prop
, Qtext
))
20336 return OK_PIXELS (width_p
20337 ? window_box_width (it
->w
, TEXT_AREA
)
20338 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
20340 if (align_to
&& *align_to
< 0)
20343 if (EQ (prop
, Qleft
))
20344 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
20345 if (EQ (prop
, Qright
))
20346 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
20347 if (EQ (prop
, Qcenter
))
20348 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
20349 + window_box_width (it
->w
, TEXT_AREA
) / 2);
20350 if (EQ (prop
, Qleft_fringe
))
20351 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
20352 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
20353 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
20354 if (EQ (prop
, Qright_fringe
))
20355 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
20356 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
20357 : window_box_right_offset (it
->w
, TEXT_AREA
));
20358 if (EQ (prop
, Qleft_margin
))
20359 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
20360 if (EQ (prop
, Qright_margin
))
20361 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
20362 if (EQ (prop
, Qscroll_bar
))
20363 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
20365 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
20366 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
20367 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
20372 if (EQ (prop
, Qleft_fringe
))
20373 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
20374 if (EQ (prop
, Qright_fringe
))
20375 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
20376 if (EQ (prop
, Qleft_margin
))
20377 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
20378 if (EQ (prop
, Qright_margin
))
20379 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
20380 if (EQ (prop
, Qscroll_bar
))
20381 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
20384 prop
= Fbuffer_local_value (prop
, it
->w
->buffer
);
20387 if (INTEGERP (prop
) || FLOATP (prop
))
20389 int base_unit
= (width_p
20390 ? FRAME_COLUMN_WIDTH (it
->f
)
20391 : FRAME_LINE_HEIGHT (it
->f
));
20392 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
20397 Lisp_Object car
= XCAR (prop
);
20398 Lisp_Object cdr
= XCDR (prop
);
20402 #ifdef HAVE_WINDOW_SYSTEM
20403 if (FRAME_WINDOW_P (it
->f
)
20404 && valid_image_p (prop
))
20406 int id
= lookup_image (it
->f
, prop
);
20407 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
20409 return OK_PIXELS (width_p
? img
->width
: img
->height
);
20412 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
20418 while (CONSP (cdr
))
20420 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
20421 font
, width_p
, align_to
))
20424 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
20429 if (EQ (car
, Qminus
))
20431 return OK_PIXELS (pixels
);
20434 car
= Fbuffer_local_value (car
, it
->w
->buffer
);
20437 if (INTEGERP (car
) || FLOATP (car
))
20440 pixels
= XFLOATINT (car
);
20442 return OK_PIXELS (pixels
);
20443 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
20444 font
, width_p
, align_to
))
20445 return OK_PIXELS (pixels
* fact
);
20456 /***********************************************************************
20458 ***********************************************************************/
20460 #ifdef HAVE_WINDOW_SYSTEM
20465 dump_glyph_string (struct glyph_string
*s
)
20467 fprintf (stderr
, "glyph string\n");
20468 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
20469 s
->x
, s
->y
, s
->width
, s
->height
);
20470 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
20471 fprintf (stderr
, " hl = %d\n", s
->hl
);
20472 fprintf (stderr
, " left overhang = %d, right = %d\n",
20473 s
->left_overhang
, s
->right_overhang
);
20474 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
20475 fprintf (stderr
, " extends to end of line = %d\n",
20476 s
->extends_to_end_of_line_p
);
20477 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
20478 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
20481 #endif /* GLYPH_DEBUG */
20483 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
20484 of XChar2b structures for S; it can't be allocated in
20485 init_glyph_string because it must be allocated via `alloca'. W
20486 is the window on which S is drawn. ROW and AREA are the glyph row
20487 and area within the row from which S is constructed. START is the
20488 index of the first glyph structure covered by S. HL is a
20489 face-override for drawing S. */
20492 #define OPTIONAL_HDC(hdc) HDC hdc,
20493 #define DECLARE_HDC(hdc) HDC hdc;
20494 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
20495 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
20498 #ifndef OPTIONAL_HDC
20499 #define OPTIONAL_HDC(hdc)
20500 #define DECLARE_HDC(hdc)
20501 #define ALLOCATE_HDC(hdc, f)
20502 #define RELEASE_HDC(hdc, f)
20506 init_glyph_string (struct glyph_string
*s
,
20508 XChar2b
*char2b
, struct window
*w
, struct glyph_row
*row
,
20509 enum glyph_row_area area
, int start
, enum draw_glyphs_face hl
)
20511 memset (s
, 0, sizeof *s
);
20513 s
->f
= XFRAME (w
->frame
);
20517 s
->display
= FRAME_X_DISPLAY (s
->f
);
20518 s
->window
= FRAME_X_WINDOW (s
->f
);
20519 s
->char2b
= char2b
;
20523 s
->first_glyph
= row
->glyphs
[area
] + start
;
20524 s
->height
= row
->height
;
20525 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
20526 s
->ybase
= s
->y
+ row
->ascent
;
20530 /* Append the list of glyph strings with head H and tail T to the list
20531 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
20534 append_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
20535 struct glyph_string
*h
, struct glyph_string
*t
)
20549 /* Prepend the list of glyph strings with head H and tail T to the
20550 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
20554 prepend_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
20555 struct glyph_string
*h
, struct glyph_string
*t
)
20569 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
20570 Set *HEAD and *TAIL to the resulting list. */
20573 append_glyph_string (struct glyph_string
**head
, struct glyph_string
**tail
,
20574 struct glyph_string
*s
)
20576 s
->next
= s
->prev
= NULL
;
20577 append_glyph_string_lists (head
, tail
, s
, s
);
20581 /* Get face and two-byte form of character C in face FACE_ID on frame F.
20582 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
20583 make sure that X resources for the face returned are allocated.
20584 Value is a pointer to a realized face that is ready for display if
20585 DISPLAY_P is non-zero. */
20587 static inline struct face
*
20588 get_char_face_and_encoding (struct frame
*f
, int c
, int face_id
,
20589 XChar2b
*char2b
, int display_p
)
20591 struct face
*face
= FACE_FROM_ID (f
, face_id
);
20595 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
20597 if (code
!= FONT_INVALID_CODE
)
20598 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
20600 STORE_XCHAR2B (char2b
, 0, 0);
20603 /* Make sure X resources of the face are allocated. */
20604 #ifdef HAVE_X_WINDOWS
20608 xassert (face
!= NULL
);
20609 PREPARE_FACE_FOR_DISPLAY (f
, face
);
20616 /* Get face and two-byte form of character glyph GLYPH on frame F.
20617 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
20618 a pointer to a realized face that is ready for display. */
20620 static inline struct face
*
20621 get_glyph_face_and_encoding (struct frame
*f
, struct glyph
*glyph
,
20622 XChar2b
*char2b
, int *two_byte_p
)
20626 xassert (glyph
->type
== CHAR_GLYPH
);
20627 face
= FACE_FROM_ID (f
, glyph
->face_id
);
20636 if (CHAR_BYTE8_P (glyph
->u
.ch
))
20637 code
= CHAR_TO_BYTE8 (glyph
->u
.ch
);
20639 code
= face
->font
->driver
->encode_char (face
->font
, glyph
->u
.ch
);
20641 if (code
!= FONT_INVALID_CODE
)
20642 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
20644 STORE_XCHAR2B (char2b
, 0, 0);
20647 /* Make sure X resources of the face are allocated. */
20648 xassert (face
!= NULL
);
20649 PREPARE_FACE_FOR_DISPLAY (f
, face
);
20654 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
20655 Retunr 1 if FONT has a glyph for C, otherwise return 0. */
20658 get_char_glyph_code (int c
, struct font
*font
, XChar2b
*char2b
)
20662 if (CHAR_BYTE8_P (c
))
20663 code
= CHAR_TO_BYTE8 (c
);
20665 code
= font
->driver
->encode_char (font
, c
);
20667 if (code
== FONT_INVALID_CODE
)
20669 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
20674 /* Fill glyph string S with composition components specified by S->cmp.
20676 BASE_FACE is the base face of the composition.
20677 S->cmp_from is the index of the first component for S.
20679 OVERLAPS non-zero means S should draw the foreground only, and use
20680 its physical height for clipping. See also draw_glyphs.
20682 Value is the index of a component not in S. */
20685 fill_composite_glyph_string (struct glyph_string
*s
, struct face
*base_face
,
20689 /* For all glyphs of this composition, starting at the offset
20690 S->cmp_from, until we reach the end of the definition or encounter a
20691 glyph that requires the different face, add it to S. */
20696 s
->for_overlaps
= overlaps
;
20699 for (i
= s
->cmp_from
; i
< s
->cmp
->glyph_len
; i
++)
20701 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
20705 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
->ascii_face
, c
,
20708 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
20715 s
->font
= s
->face
->font
;
20717 else if (s
->face
!= face
)
20725 /* All glyph strings for the same composition has the same width,
20726 i.e. the width set for the first component of the composition. */
20727 s
->width
= s
->first_glyph
->pixel_width
;
20729 /* If the specified font could not be loaded, use the frame's
20730 default font, but record the fact that we couldn't load it in
20731 the glyph string so that we can draw rectangles for the
20732 characters of the glyph string. */
20733 if (s
->font
== NULL
)
20735 s
->font_not_found_p
= 1;
20736 s
->font
= FRAME_FONT (s
->f
);
20739 /* Adjust base line for subscript/superscript text. */
20740 s
->ybase
+= s
->first_glyph
->voffset
;
20742 /* This glyph string must always be drawn with 16-bit functions. */
20749 fill_gstring_glyph_string (struct glyph_string
*s
, int face_id
,
20750 int start
, int end
, int overlaps
)
20752 struct glyph
*glyph
, *last
;
20753 Lisp_Object lgstring
;
20756 s
->for_overlaps
= overlaps
;
20757 glyph
= s
->row
->glyphs
[s
->area
] + start
;
20758 last
= s
->row
->glyphs
[s
->area
] + end
;
20759 s
->cmp_id
= glyph
->u
.cmp
.id
;
20760 s
->cmp_from
= glyph
->slice
.cmp
.from
;
20761 s
->cmp_to
= glyph
->slice
.cmp
.to
+ 1;
20762 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
20763 lgstring
= composition_gstring_from_id (s
->cmp_id
);
20764 s
->font
= XFONT_OBJECT (LGSTRING_FONT (lgstring
));
20766 while (glyph
< last
20767 && glyph
->u
.cmp
.automatic
20768 && glyph
->u
.cmp
.id
== s
->cmp_id
20769 && s
->cmp_to
== glyph
->slice
.cmp
.from
)
20770 s
->cmp_to
= (glyph
++)->slice
.cmp
.to
+ 1;
20772 for (i
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
20774 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
20775 unsigned code
= LGLYPH_CODE (lglyph
);
20777 STORE_XCHAR2B ((s
->char2b
+ i
), code
>> 8, code
& 0xFF);
20779 s
->width
= composition_gstring_width (lgstring
, s
->cmp_from
, s
->cmp_to
, NULL
);
20780 return glyph
- s
->row
->glyphs
[s
->area
];
20784 /* Fill glyph string S from a sequence glyphs for glyphless characters.
20785 See the comment of fill_glyph_string for arguments.
20786 Value is the index of the first glyph not in S. */
20790 fill_glyphless_glyph_string (struct glyph_string
*s
, int face_id
,
20791 int start
, int end
, int overlaps
)
20793 struct glyph
*glyph
, *last
;
20796 xassert (s
->first_glyph
->type
== GLYPHLESS_GLYPH
);
20797 s
->for_overlaps
= overlaps
;
20798 glyph
= s
->row
->glyphs
[s
->area
] + start
;
20799 last
= s
->row
->glyphs
[s
->area
] + end
;
20800 voffset
= glyph
->voffset
;
20801 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
20802 s
->font
= s
->face
->font
;
20804 s
->width
= glyph
->pixel_width
;
20806 while (glyph
< last
20807 && glyph
->type
== GLYPHLESS_GLYPH
20808 && glyph
->voffset
== voffset
20809 && glyph
->face_id
== face_id
)
20812 s
->width
+= glyph
->pixel_width
;
20815 s
->ybase
+= voffset
;
20816 return glyph
- s
->row
->glyphs
[s
->area
];
20820 /* Fill glyph string S from a sequence of character glyphs.
20822 FACE_ID is the face id of the string. START is the index of the
20823 first glyph to consider, END is the index of the last + 1.
20824 OVERLAPS non-zero means S should draw the foreground only, and use
20825 its physical height for clipping. See also draw_glyphs.
20827 Value is the index of the first glyph not in S. */
20830 fill_glyph_string (struct glyph_string
*s
, int face_id
,
20831 int start
, int end
, int overlaps
)
20833 struct glyph
*glyph
, *last
;
20835 int glyph_not_available_p
;
20837 xassert (s
->f
== XFRAME (s
->w
->frame
));
20838 xassert (s
->nchars
== 0);
20839 xassert (start
>= 0 && end
> start
);
20841 s
->for_overlaps
= overlaps
;
20842 glyph
= s
->row
->glyphs
[s
->area
] + start
;
20843 last
= s
->row
->glyphs
[s
->area
] + end
;
20844 voffset
= glyph
->voffset
;
20845 s
->padding_p
= glyph
->padding_p
;
20846 glyph_not_available_p
= glyph
->glyph_not_available_p
;
20848 while (glyph
< last
20849 && glyph
->type
== CHAR_GLYPH
20850 && glyph
->voffset
== voffset
20851 /* Same face id implies same font, nowadays. */
20852 && glyph
->face_id
== face_id
20853 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
20857 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
20858 s
->char2b
+ s
->nchars
,
20860 s
->two_byte_p
= two_byte_p
;
20862 xassert (s
->nchars
<= end
- start
);
20863 s
->width
+= glyph
->pixel_width
;
20864 if (glyph
++->padding_p
!= s
->padding_p
)
20868 s
->font
= s
->face
->font
;
20870 /* If the specified font could not be loaded, use the frame's font,
20871 but record the fact that we couldn't load it in
20872 S->font_not_found_p so that we can draw rectangles for the
20873 characters of the glyph string. */
20874 if (s
->font
== NULL
|| glyph_not_available_p
)
20876 s
->font_not_found_p
= 1;
20877 s
->font
= FRAME_FONT (s
->f
);
20880 /* Adjust base line for subscript/superscript text. */
20881 s
->ybase
+= voffset
;
20883 xassert (s
->face
&& s
->face
->gc
);
20884 return glyph
- s
->row
->glyphs
[s
->area
];
20888 /* Fill glyph string S from image glyph S->first_glyph. */
20891 fill_image_glyph_string (struct glyph_string
*s
)
20893 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
20894 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
20896 s
->slice
= s
->first_glyph
->slice
.img
;
20897 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
20898 s
->font
= s
->face
->font
;
20899 s
->width
= s
->first_glyph
->pixel_width
;
20901 /* Adjust base line for subscript/superscript text. */
20902 s
->ybase
+= s
->first_glyph
->voffset
;
20906 /* Fill glyph string S from a sequence of stretch glyphs.
20908 START is the index of the first glyph to consider,
20909 END is the index of the last + 1.
20911 Value is the index of the first glyph not in S. */
20914 fill_stretch_glyph_string (struct glyph_string
*s
, int start
, int end
)
20916 struct glyph
*glyph
, *last
;
20917 int voffset
, face_id
;
20919 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
20921 glyph
= s
->row
->glyphs
[s
->area
] + start
;
20922 last
= s
->row
->glyphs
[s
->area
] + end
;
20923 face_id
= glyph
->face_id
;
20924 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
20925 s
->font
= s
->face
->font
;
20926 s
->width
= glyph
->pixel_width
;
20928 voffset
= glyph
->voffset
;
20932 && glyph
->type
== STRETCH_GLYPH
20933 && glyph
->voffset
== voffset
20934 && glyph
->face_id
== face_id
);
20936 s
->width
+= glyph
->pixel_width
;
20938 /* Adjust base line for subscript/superscript text. */
20939 s
->ybase
+= voffset
;
20941 /* The case that face->gc == 0 is handled when drawing the glyph
20942 string by calling PREPARE_FACE_FOR_DISPLAY. */
20944 return glyph
- s
->row
->glyphs
[s
->area
];
20947 static struct font_metrics
*
20948 get_per_char_metric (struct font
*font
, XChar2b
*char2b
)
20950 static struct font_metrics metrics
;
20951 unsigned code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
20953 if (! font
|| code
== FONT_INVALID_CODE
)
20955 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
20960 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
20961 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
20962 assumed to be zero. */
20965 x_get_glyph_overhangs (struct glyph
*glyph
, struct frame
*f
, int *left
, int *right
)
20967 *left
= *right
= 0;
20969 if (glyph
->type
== CHAR_GLYPH
)
20973 struct font_metrics
*pcm
;
20975 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
20976 if (face
->font
&& (pcm
= get_per_char_metric (face
->font
, &char2b
)))
20978 if (pcm
->rbearing
> pcm
->width
)
20979 *right
= pcm
->rbearing
- pcm
->width
;
20980 if (pcm
->lbearing
< 0)
20981 *left
= -pcm
->lbearing
;
20984 else if (glyph
->type
== COMPOSITE_GLYPH
)
20986 if (! glyph
->u
.cmp
.automatic
)
20988 struct composition
*cmp
= composition_table
[glyph
->u
.cmp
.id
];
20990 if (cmp
->rbearing
> cmp
->pixel_width
)
20991 *right
= cmp
->rbearing
- cmp
->pixel_width
;
20992 if (cmp
->lbearing
< 0)
20993 *left
= - cmp
->lbearing
;
20997 Lisp_Object gstring
= composition_gstring_from_id (glyph
->u
.cmp
.id
);
20998 struct font_metrics metrics
;
21000 composition_gstring_width (gstring
, glyph
->slice
.cmp
.from
,
21001 glyph
->slice
.cmp
.to
+ 1, &metrics
);
21002 if (metrics
.rbearing
> metrics
.width
)
21003 *right
= metrics
.rbearing
- metrics
.width
;
21004 if (metrics
.lbearing
< 0)
21005 *left
= - metrics
.lbearing
;
21011 /* Return the index of the first glyph preceding glyph string S that
21012 is overwritten by S because of S's left overhang. Value is -1
21013 if no glyphs are overwritten. */
21016 left_overwritten (struct glyph_string
*s
)
21020 if (s
->left_overhang
)
21023 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21024 int first
= s
->first_glyph
- glyphs
;
21026 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
21027 x
-= glyphs
[i
].pixel_width
;
21038 /* Return the index of the first glyph preceding glyph string S that
21039 is overwriting S because of its right overhang. Value is -1 if no
21040 glyph in front of S overwrites S. */
21043 left_overwriting (struct glyph_string
*s
)
21046 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21047 int first
= s
->first_glyph
- glyphs
;
21051 for (i
= first
- 1; i
>= 0; --i
)
21054 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
21057 x
-= glyphs
[i
].pixel_width
;
21064 /* Return the index of the last glyph following glyph string S that is
21065 overwritten by S because of S's right overhang. Value is -1 if
21066 no such glyph is found. */
21069 right_overwritten (struct glyph_string
*s
)
21073 if (s
->right_overhang
)
21076 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21077 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
21078 int end
= s
->row
->used
[s
->area
];
21080 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
21081 x
+= glyphs
[i
].pixel_width
;
21090 /* Return the index of the last glyph following glyph string S that
21091 overwrites S because of its left overhang. Value is negative
21092 if no such glyph is found. */
21095 right_overwriting (struct glyph_string
*s
)
21098 int end
= s
->row
->used
[s
->area
];
21099 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21100 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
21104 for (i
= first
; i
< end
; ++i
)
21107 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
21110 x
+= glyphs
[i
].pixel_width
;
21117 /* Set background width of glyph string S. START is the index of the
21118 first glyph following S. LAST_X is the right-most x-position + 1
21119 in the drawing area. */
21122 set_glyph_string_background_width (struct glyph_string
*s
, int start
, int last_x
)
21124 /* If the face of this glyph string has to be drawn to the end of
21125 the drawing area, set S->extends_to_end_of_line_p. */
21127 if (start
== s
->row
->used
[s
->area
]
21128 && s
->area
== TEXT_AREA
21129 && ((s
->row
->fill_line_p
21130 && (s
->hl
== DRAW_NORMAL_TEXT
21131 || s
->hl
== DRAW_IMAGE_RAISED
21132 || s
->hl
== DRAW_IMAGE_SUNKEN
))
21133 || s
->hl
== DRAW_MOUSE_FACE
))
21134 s
->extends_to_end_of_line_p
= 1;
21136 /* If S extends its face to the end of the line, set its
21137 background_width to the distance to the right edge of the drawing
21139 if (s
->extends_to_end_of_line_p
)
21140 s
->background_width
= last_x
- s
->x
+ 1;
21142 s
->background_width
= s
->width
;
21146 /* Compute overhangs and x-positions for glyph string S and its
21147 predecessors, or successors. X is the starting x-position for S.
21148 BACKWARD_P non-zero means process predecessors. */
21151 compute_overhangs_and_x (struct glyph_string
*s
, int x
, int backward_p
)
21157 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
21158 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
21168 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
21169 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
21179 /* The following macros are only called from draw_glyphs below.
21180 They reference the following parameters of that function directly:
21181 `w', `row', `area', and `overlap_p'
21182 as well as the following local variables:
21183 `s', `f', and `hdc' (in W32) */
21186 /* On W32, silently add local `hdc' variable to argument list of
21187 init_glyph_string. */
21188 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21189 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
21191 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21192 init_glyph_string (s, char2b, w, row, area, start, hl)
21195 /* Add a glyph string for a stretch glyph to the list of strings
21196 between HEAD and TAIL. START is the index of the stretch glyph in
21197 row area AREA of glyph row ROW. END is the index of the last glyph
21198 in that glyph row area. X is the current output position assigned
21199 to the new glyph string constructed. HL overrides that face of the
21200 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
21201 is the right-most x-position of the drawing area. */
21203 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
21204 and below -- keep them on one line. */
21205 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21208 s = (struct glyph_string *) alloca (sizeof *s); \
21209 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
21210 START = fill_stretch_glyph_string (s, START, END); \
21211 append_glyph_string (&HEAD, &TAIL, s); \
21217 /* Add a glyph string for an image glyph to the list of strings
21218 between HEAD and TAIL. START is the index of the image glyph in
21219 row area AREA of glyph row ROW. END is the index of the last glyph
21220 in that glyph row area. X is the current output position assigned
21221 to the new glyph string constructed. HL overrides that face of the
21222 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
21223 is the right-most x-position of the drawing area. */
21225 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21228 s = (struct glyph_string *) alloca (sizeof *s); \
21229 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
21230 fill_image_glyph_string (s); \
21231 append_glyph_string (&HEAD, &TAIL, s); \
21238 /* Add a glyph string for a sequence of character glyphs to the list
21239 of strings between HEAD and TAIL. START is the index of the first
21240 glyph in row area AREA of glyph row ROW that is part of the new
21241 glyph string. END is the index of the last glyph in that glyph row
21242 area. X is the current output position assigned to the new glyph
21243 string constructed. HL overrides that face of the glyph; e.g. it
21244 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
21245 right-most x-position of the drawing area. */
21247 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
21253 face_id = (row)->glyphs[area][START].face_id; \
21255 s = (struct glyph_string *) alloca (sizeof *s); \
21256 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
21257 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21258 append_glyph_string (&HEAD, &TAIL, s); \
21260 START = fill_glyph_string (s, face_id, START, END, overlaps); \
21265 /* Add a glyph string for a composite sequence to the list of strings
21266 between HEAD and TAIL. START is the index of the first glyph in
21267 row area AREA of glyph row ROW that is part of the new glyph
21268 string. END is the index of the last glyph in that glyph row area.
21269 X is the current output position assigned to the new glyph string
21270 constructed. HL overrides that face of the glyph; e.g. it is
21271 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
21272 x-position of the drawing area. */
21274 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21276 int face_id = (row)->glyphs[area][START].face_id; \
21277 struct face *base_face = FACE_FROM_ID (f, face_id); \
21278 int cmp_id = (row)->glyphs[area][START].u.cmp.id; \
21279 struct composition *cmp = composition_table[cmp_id]; \
21281 struct glyph_string *first_s IF_LINT (= NULL); \
21284 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
21286 /* Make glyph_strings for each glyph sequence that is drawable by \
21287 the same face, and append them to HEAD/TAIL. */ \
21288 for (n = 0; n < cmp->glyph_len;) \
21290 s = (struct glyph_string *) alloca (sizeof *s); \
21291 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21292 append_glyph_string (&(HEAD), &(TAIL), s); \
21298 n = fill_composite_glyph_string (s, base_face, overlaps); \
21306 /* Add a glyph string for a glyph-string sequence to the list of strings
21307 between HEAD and TAIL. */
21309 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21313 Lisp_Object gstring; \
21315 face_id = (row)->glyphs[area][START].face_id; \
21316 gstring = (composition_gstring_from_id \
21317 ((row)->glyphs[area][START].u.cmp.id)); \
21318 s = (struct glyph_string *) alloca (sizeof *s); \
21319 char2b = (XChar2b *) alloca ((sizeof *char2b) \
21320 * LGSTRING_GLYPH_LEN (gstring)); \
21321 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
21322 append_glyph_string (&(HEAD), &(TAIL), s); \
21324 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
21328 /* Add a glyph string for a sequence of glyphless character's glyphs
21329 to the list of strings between HEAD and TAIL. The meanings of
21330 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
21332 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21337 face_id = (row)->glyphs[area][START].face_id; \
21339 s = (struct glyph_string *) alloca (sizeof *s); \
21340 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
21341 append_glyph_string (&HEAD, &TAIL, s); \
21343 START = fill_glyphless_glyph_string (s, face_id, START, END, \
21349 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
21350 of AREA of glyph row ROW on window W between indices START and END.
21351 HL overrides the face for drawing glyph strings, e.g. it is
21352 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
21353 x-positions of the drawing area.
21355 This is an ugly monster macro construct because we must use alloca
21356 to allocate glyph strings (because draw_glyphs can be called
21357 asynchronously). */
21359 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
21362 HEAD = TAIL = NULL; \
21363 while (START < END) \
21365 struct glyph *first_glyph = (row)->glyphs[area] + START; \
21366 switch (first_glyph->type) \
21369 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
21373 case COMPOSITE_GLYPH: \
21374 if (first_glyph->u.cmp.automatic) \
21375 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
21378 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
21382 case STRETCH_GLYPH: \
21383 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
21387 case IMAGE_GLYPH: \
21388 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
21392 case GLYPHLESS_GLYPH: \
21393 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
21403 set_glyph_string_background_width (s, START, LAST_X); \
21410 /* Draw glyphs between START and END in AREA of ROW on window W,
21411 starting at x-position X. X is relative to AREA in W. HL is a
21412 face-override with the following meaning:
21414 DRAW_NORMAL_TEXT draw normally
21415 DRAW_CURSOR draw in cursor face
21416 DRAW_MOUSE_FACE draw in mouse face.
21417 DRAW_INVERSE_VIDEO draw in mode line face
21418 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
21419 DRAW_IMAGE_RAISED draw an image with a raised relief around it
21421 If OVERLAPS is non-zero, draw only the foreground of characters and
21422 clip to the physical height of ROW. Non-zero value also defines
21423 the overlapping part to be drawn:
21425 OVERLAPS_PRED overlap with preceding rows
21426 OVERLAPS_SUCC overlap with succeeding rows
21427 OVERLAPS_BOTH overlap with both preceding/succeeding rows
21428 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
21430 Value is the x-position reached, relative to AREA of W. */
21433 draw_glyphs (struct window
*w
, int x
, struct glyph_row
*row
,
21434 enum glyph_row_area area
, EMACS_INT start
, EMACS_INT end
,
21435 enum draw_glyphs_face hl
, int overlaps
)
21437 struct glyph_string
*head
, *tail
;
21438 struct glyph_string
*s
;
21439 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
21440 int i
, j
, x_reached
, last_x
, area_left
= 0;
21441 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
21444 ALLOCATE_HDC (hdc
, f
);
21446 /* Let's rather be paranoid than getting a SEGV. */
21447 end
= min (end
, row
->used
[area
]);
21448 start
= max (0, start
);
21449 start
= min (end
, start
);
21451 /* Translate X to frame coordinates. Set last_x to the right
21452 end of the drawing area. */
21453 if (row
->full_width_p
)
21455 /* X is relative to the left edge of W, without scroll bars
21457 area_left
= WINDOW_LEFT_EDGE_X (w
);
21458 last_x
= WINDOW_LEFT_EDGE_X (w
) + WINDOW_TOTAL_WIDTH (w
);
21462 area_left
= window_box_left (w
, area
);
21463 last_x
= area_left
+ window_box_width (w
, area
);
21467 /* Build a doubly-linked list of glyph_string structures between
21468 head and tail from what we have to draw. Note that the macro
21469 BUILD_GLYPH_STRINGS will modify its start parameter. That's
21470 the reason we use a separate variable `i'. */
21472 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
21474 x_reached
= tail
->x
+ tail
->background_width
;
21478 /* If there are any glyphs with lbearing < 0 or rbearing > width in
21479 the row, redraw some glyphs in front or following the glyph
21480 strings built above. */
21481 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
21483 struct glyph_string
*h
, *t
;
21484 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
21485 int mouse_beg_col
IF_LINT (= 0), mouse_end_col
IF_LINT (= 0);
21486 int check_mouse_face
= 0;
21489 /* If mouse highlighting is on, we may need to draw adjacent
21490 glyphs using mouse-face highlighting. */
21491 if (area
== TEXT_AREA
&& row
->mouse_face_p
)
21493 struct glyph_row
*mouse_beg_row
, *mouse_end_row
;
21495 mouse_beg_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
21496 mouse_end_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
21498 if (row
>= mouse_beg_row
&& row
<= mouse_end_row
)
21500 check_mouse_face
= 1;
21501 mouse_beg_col
= (row
== mouse_beg_row
)
21502 ? hlinfo
->mouse_face_beg_col
: 0;
21503 mouse_end_col
= (row
== mouse_end_row
)
21504 ? hlinfo
->mouse_face_end_col
21505 : row
->used
[TEXT_AREA
];
21509 /* Compute overhangs for all glyph strings. */
21510 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
21511 for (s
= head
; s
; s
= s
->next
)
21512 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
21514 /* Prepend glyph strings for glyphs in front of the first glyph
21515 string that are overwritten because of the first glyph
21516 string's left overhang. The background of all strings
21517 prepended must be drawn because the first glyph string
21519 i
= left_overwritten (head
);
21522 enum draw_glyphs_face overlap_hl
;
21524 /* If this row contains mouse highlighting, attempt to draw
21525 the overlapped glyphs with the correct highlight. This
21526 code fails if the overlap encompasses more than one glyph
21527 and mouse-highlight spans only some of these glyphs.
21528 However, making it work perfectly involves a lot more
21529 code, and I don't know if the pathological case occurs in
21530 practice, so we'll stick to this for now. --- cyd */
21531 if (check_mouse_face
21532 && mouse_beg_col
< start
&& mouse_end_col
> i
)
21533 overlap_hl
= DRAW_MOUSE_FACE
;
21535 overlap_hl
= DRAW_NORMAL_TEXT
;
21538 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
21539 overlap_hl
, dummy_x
, last_x
);
21541 compute_overhangs_and_x (t
, head
->x
, 1);
21542 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
21546 /* Prepend glyph strings for glyphs in front of the first glyph
21547 string that overwrite that glyph string because of their
21548 right overhang. For these strings, only the foreground must
21549 be drawn, because it draws over the glyph string at `head'.
21550 The background must not be drawn because this would overwrite
21551 right overhangs of preceding glyphs for which no glyph
21553 i
= left_overwriting (head
);
21556 enum draw_glyphs_face overlap_hl
;
21558 if (check_mouse_face
21559 && mouse_beg_col
< start
&& mouse_end_col
> i
)
21560 overlap_hl
= DRAW_MOUSE_FACE
;
21562 overlap_hl
= DRAW_NORMAL_TEXT
;
21565 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
21566 overlap_hl
, dummy_x
, last_x
);
21567 for (s
= h
; s
; s
= s
->next
)
21568 s
->background_filled_p
= 1;
21569 compute_overhangs_and_x (t
, head
->x
, 1);
21570 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
21573 /* Append glyphs strings for glyphs following the last glyph
21574 string tail that are overwritten by tail. The background of
21575 these strings has to be drawn because tail's foreground draws
21577 i
= right_overwritten (tail
);
21580 enum draw_glyphs_face overlap_hl
;
21582 if (check_mouse_face
21583 && mouse_beg_col
< i
&& mouse_end_col
> end
)
21584 overlap_hl
= DRAW_MOUSE_FACE
;
21586 overlap_hl
= DRAW_NORMAL_TEXT
;
21588 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
21589 overlap_hl
, x
, last_x
);
21590 /* Because BUILD_GLYPH_STRINGS updates the first argument,
21591 we don't have `end = i;' here. */
21592 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
21593 append_glyph_string_lists (&head
, &tail
, h
, t
);
21597 /* Append glyph strings for glyphs following the last glyph
21598 string tail that overwrite tail. The foreground of such
21599 glyphs has to be drawn because it writes into the background
21600 of tail. The background must not be drawn because it could
21601 paint over the foreground of following glyphs. */
21602 i
= right_overwriting (tail
);
21605 enum draw_glyphs_face overlap_hl
;
21606 if (check_mouse_face
21607 && mouse_beg_col
< i
&& mouse_end_col
> end
)
21608 overlap_hl
= DRAW_MOUSE_FACE
;
21610 overlap_hl
= DRAW_NORMAL_TEXT
;
21613 i
++; /* We must include the Ith glyph. */
21614 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
21615 overlap_hl
, x
, last_x
);
21616 for (s
= h
; s
; s
= s
->next
)
21617 s
->background_filled_p
= 1;
21618 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
21619 append_glyph_string_lists (&head
, &tail
, h
, t
);
21621 if (clip_head
|| clip_tail
)
21622 for (s
= head
; s
; s
= s
->next
)
21624 s
->clip_head
= clip_head
;
21625 s
->clip_tail
= clip_tail
;
21629 /* Draw all strings. */
21630 for (s
= head
; s
; s
= s
->next
)
21631 FRAME_RIF (f
)->draw_glyph_string (s
);
21634 /* When focus a sole frame and move horizontally, this sets on_p to 0
21635 causing a failure to erase prev cursor position. */
21636 if (area
== TEXT_AREA
21637 && !row
->full_width_p
21638 /* When drawing overlapping rows, only the glyph strings'
21639 foreground is drawn, which doesn't erase a cursor
21643 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
21644 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
21645 : (tail
? tail
->x
+ tail
->background_width
: x
));
21649 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
21650 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
21654 /* Value is the x-position up to which drawn, relative to AREA of W.
21655 This doesn't include parts drawn because of overhangs. */
21656 if (row
->full_width_p
)
21657 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
21659 x_reached
-= area_left
;
21661 RELEASE_HDC (hdc
, f
);
21666 /* Expand row matrix if too narrow. Don't expand if area
21669 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
21671 if (!fonts_changed_p \
21672 && (it->glyph_row->glyphs[area] \
21673 < it->glyph_row->glyphs[area + 1])) \
21675 it->w->ncols_scale_factor++; \
21676 fonts_changed_p = 1; \
21680 /* Store one glyph for IT->char_to_display in IT->glyph_row.
21681 Called from x_produce_glyphs when IT->glyph_row is non-null. */
21684 append_glyph (struct it
*it
)
21686 struct glyph
*glyph
;
21687 enum glyph_row_area area
= it
->area
;
21689 xassert (it
->glyph_row
);
21690 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
21692 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
21693 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
21695 /* If the glyph row is reversed, we need to prepend the glyph
21696 rather than append it. */
21697 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
21701 /* Make room for the additional glyph. */
21702 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
21704 glyph
= it
->glyph_row
->glyphs
[area
];
21706 glyph
->charpos
= CHARPOS (it
->position
);
21707 glyph
->object
= it
->object
;
21708 if (it
->pixel_width
> 0)
21710 glyph
->pixel_width
= it
->pixel_width
;
21711 glyph
->padding_p
= 0;
21715 /* Assure at least 1-pixel width. Otherwise, cursor can't
21716 be displayed correctly. */
21717 glyph
->pixel_width
= 1;
21718 glyph
->padding_p
= 1;
21720 glyph
->ascent
= it
->ascent
;
21721 glyph
->descent
= it
->descent
;
21722 glyph
->voffset
= it
->voffset
;
21723 glyph
->type
= CHAR_GLYPH
;
21724 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
21725 glyph
->multibyte_p
= it
->multibyte_p
;
21726 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
21727 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
21728 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
21729 || it
->phys_descent
> it
->descent
);
21730 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
21731 glyph
->face_id
= it
->face_id
;
21732 glyph
->u
.ch
= it
->char_to_display
;
21733 glyph
->slice
.img
= null_glyph_slice
;
21734 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
21737 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
21738 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
21740 glyph
->bidi_type
= it
->bidi_it
.type
;
21744 glyph
->resolved_level
= 0;
21745 glyph
->bidi_type
= UNKNOWN_BT
;
21747 ++it
->glyph_row
->used
[area
];
21750 IT_EXPAND_MATRIX_WIDTH (it
, area
);
21753 /* Store one glyph for the composition IT->cmp_it.id in
21754 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
21758 append_composite_glyph (struct it
*it
)
21760 struct glyph
*glyph
;
21761 enum glyph_row_area area
= it
->area
;
21763 xassert (it
->glyph_row
);
21765 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
21766 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
21768 /* If the glyph row is reversed, we need to prepend the glyph
21769 rather than append it. */
21770 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
21774 /* Make room for the new glyph. */
21775 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
21777 glyph
= it
->glyph_row
->glyphs
[it
->area
];
21779 glyph
->charpos
= it
->cmp_it
.charpos
;
21780 glyph
->object
= it
->object
;
21781 glyph
->pixel_width
= it
->pixel_width
;
21782 glyph
->ascent
= it
->ascent
;
21783 glyph
->descent
= it
->descent
;
21784 glyph
->voffset
= it
->voffset
;
21785 glyph
->type
= COMPOSITE_GLYPH
;
21786 if (it
->cmp_it
.ch
< 0)
21788 glyph
->u
.cmp
.automatic
= 0;
21789 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
21790 glyph
->slice
.cmp
.from
= glyph
->slice
.cmp
.to
= 0;
21794 glyph
->u
.cmp
.automatic
= 1;
21795 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
21796 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
21797 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
21799 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
21800 glyph
->multibyte_p
= it
->multibyte_p
;
21801 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
21802 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
21803 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
21804 || it
->phys_descent
> it
->descent
);
21805 glyph
->padding_p
= 0;
21806 glyph
->glyph_not_available_p
= 0;
21807 glyph
->face_id
= it
->face_id
;
21808 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
21811 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
21812 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
21814 glyph
->bidi_type
= it
->bidi_it
.type
;
21816 ++it
->glyph_row
->used
[area
];
21819 IT_EXPAND_MATRIX_WIDTH (it
, area
);
21823 /* Change IT->ascent and IT->height according to the setting of
21827 take_vertical_position_into_account (struct it
*it
)
21831 if (it
->voffset
< 0)
21832 /* Increase the ascent so that we can display the text higher
21834 it
->ascent
-= it
->voffset
;
21836 /* Increase the descent so that we can display the text lower
21838 it
->descent
+= it
->voffset
;
21843 /* Produce glyphs/get display metrics for the image IT is loaded with.
21844 See the description of struct display_iterator in dispextern.h for
21845 an overview of struct display_iterator. */
21848 produce_image_glyph (struct it
*it
)
21852 int glyph_ascent
, crop
;
21853 struct glyph_slice slice
;
21855 xassert (it
->what
== IT_IMAGE
);
21857 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
21859 /* Make sure X resources of the face is loaded. */
21860 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
21862 if (it
->image_id
< 0)
21864 /* Fringe bitmap. */
21865 it
->ascent
= it
->phys_ascent
= 0;
21866 it
->descent
= it
->phys_descent
= 0;
21867 it
->pixel_width
= 0;
21872 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
21874 /* Make sure X resources of the image is loaded. */
21875 prepare_image_for_display (it
->f
, img
);
21877 slice
.x
= slice
.y
= 0;
21878 slice
.width
= img
->width
;
21879 slice
.height
= img
->height
;
21881 if (INTEGERP (it
->slice
.x
))
21882 slice
.x
= XINT (it
->slice
.x
);
21883 else if (FLOATP (it
->slice
.x
))
21884 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
21886 if (INTEGERP (it
->slice
.y
))
21887 slice
.y
= XINT (it
->slice
.y
);
21888 else if (FLOATP (it
->slice
.y
))
21889 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
21891 if (INTEGERP (it
->slice
.width
))
21892 slice
.width
= XINT (it
->slice
.width
);
21893 else if (FLOATP (it
->slice
.width
))
21894 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
21896 if (INTEGERP (it
->slice
.height
))
21897 slice
.height
= XINT (it
->slice
.height
);
21898 else if (FLOATP (it
->slice
.height
))
21899 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
21901 if (slice
.x
>= img
->width
)
21902 slice
.x
= img
->width
;
21903 if (slice
.y
>= img
->height
)
21904 slice
.y
= img
->height
;
21905 if (slice
.x
+ slice
.width
>= img
->width
)
21906 slice
.width
= img
->width
- slice
.x
;
21907 if (slice
.y
+ slice
.height
> img
->height
)
21908 slice
.height
= img
->height
- slice
.y
;
21910 if (slice
.width
== 0 || slice
.height
== 0)
21913 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
21915 it
->descent
= slice
.height
- glyph_ascent
;
21917 it
->descent
+= img
->vmargin
;
21918 if (slice
.y
+ slice
.height
== img
->height
)
21919 it
->descent
+= img
->vmargin
;
21920 it
->phys_descent
= it
->descent
;
21922 it
->pixel_width
= slice
.width
;
21924 it
->pixel_width
+= img
->hmargin
;
21925 if (slice
.x
+ slice
.width
== img
->width
)
21926 it
->pixel_width
+= img
->hmargin
;
21928 /* It's quite possible for images to have an ascent greater than
21929 their height, so don't get confused in that case. */
21930 if (it
->descent
< 0)
21935 if (face
->box
!= FACE_NO_BOX
)
21937 if (face
->box_line_width
> 0)
21940 it
->ascent
+= face
->box_line_width
;
21941 if (slice
.y
+ slice
.height
== img
->height
)
21942 it
->descent
+= face
->box_line_width
;
21945 if (it
->start_of_box_run_p
&& slice
.x
== 0)
21946 it
->pixel_width
+= eabs (face
->box_line_width
);
21947 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
21948 it
->pixel_width
+= eabs (face
->box_line_width
);
21951 take_vertical_position_into_account (it
);
21953 /* Automatically crop wide image glyphs at right edge so we can
21954 draw the cursor on same display row. */
21955 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
21956 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
21958 it
->pixel_width
-= crop
;
21959 slice
.width
-= crop
;
21964 struct glyph
*glyph
;
21965 enum glyph_row_area area
= it
->area
;
21967 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
21968 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
21970 glyph
->charpos
= CHARPOS (it
->position
);
21971 glyph
->object
= it
->object
;
21972 glyph
->pixel_width
= it
->pixel_width
;
21973 glyph
->ascent
= glyph_ascent
;
21974 glyph
->descent
= it
->descent
;
21975 glyph
->voffset
= it
->voffset
;
21976 glyph
->type
= IMAGE_GLYPH
;
21977 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
21978 glyph
->multibyte_p
= it
->multibyte_p
;
21979 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
21980 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
21981 glyph
->overlaps_vertically_p
= 0;
21982 glyph
->padding_p
= 0;
21983 glyph
->glyph_not_available_p
= 0;
21984 glyph
->face_id
= it
->face_id
;
21985 glyph
->u
.img_id
= img
->id
;
21986 glyph
->slice
.img
= slice
;
21987 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
21990 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
21991 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
21993 glyph
->bidi_type
= it
->bidi_it
.type
;
21995 ++it
->glyph_row
->used
[area
];
21998 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22003 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
22004 of the glyph, WIDTH and HEIGHT are the width and height of the
22005 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
22008 append_stretch_glyph (struct it
*it
, Lisp_Object object
,
22009 int width
, int height
, int ascent
)
22011 struct glyph
*glyph
;
22012 enum glyph_row_area area
= it
->area
;
22014 xassert (ascent
>= 0 && ascent
<= height
);
22016 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22017 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22019 /* If the glyph row is reversed, we need to prepend the glyph
22020 rather than append it. */
22021 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
22025 /* Make room for the additional glyph. */
22026 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
22028 glyph
= it
->glyph_row
->glyphs
[area
];
22030 glyph
->charpos
= CHARPOS (it
->position
);
22031 glyph
->object
= object
;
22032 glyph
->pixel_width
= width
;
22033 glyph
->ascent
= ascent
;
22034 glyph
->descent
= height
- ascent
;
22035 glyph
->voffset
= it
->voffset
;
22036 glyph
->type
= STRETCH_GLYPH
;
22037 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22038 glyph
->multibyte_p
= it
->multibyte_p
;
22039 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22040 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22041 glyph
->overlaps_vertically_p
= 0;
22042 glyph
->padding_p
= 0;
22043 glyph
->glyph_not_available_p
= 0;
22044 glyph
->face_id
= it
->face_id
;
22045 glyph
->u
.stretch
.ascent
= ascent
;
22046 glyph
->u
.stretch
.height
= height
;
22047 glyph
->slice
.img
= null_glyph_slice
;
22048 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22051 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22052 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22054 glyph
->bidi_type
= it
->bidi_it
.type
;
22058 glyph
->resolved_level
= 0;
22059 glyph
->bidi_type
= UNKNOWN_BT
;
22061 ++it
->glyph_row
->used
[area
];
22064 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22068 /* Produce a stretch glyph for iterator IT. IT->object is the value
22069 of the glyph property displayed. The value must be a list
22070 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
22073 1. `:width WIDTH' specifies that the space should be WIDTH *
22074 canonical char width wide. WIDTH may be an integer or floating
22077 2. `:relative-width FACTOR' specifies that the width of the stretch
22078 should be computed from the width of the first character having the
22079 `glyph' property, and should be FACTOR times that width.
22081 3. `:align-to HPOS' specifies that the space should be wide enough
22082 to reach HPOS, a value in canonical character units.
22084 Exactly one of the above pairs must be present.
22086 4. `:height HEIGHT' specifies that the height of the stretch produced
22087 should be HEIGHT, measured in canonical character units.
22089 5. `:relative-height FACTOR' specifies that the height of the
22090 stretch should be FACTOR times the height of the characters having
22091 the glyph property.
22093 Either none or exactly one of 4 or 5 must be present.
22095 6. `:ascent ASCENT' specifies that ASCENT percent of the height
22096 of the stretch should be used for the ascent of the stretch.
22097 ASCENT must be in the range 0 <= ASCENT <= 100. */
22100 produce_stretch_glyph (struct it
*it
)
22102 /* (space :width WIDTH :height HEIGHT ...) */
22103 Lisp_Object prop
, plist
;
22104 int width
= 0, height
= 0, align_to
= -1;
22105 int zero_width_ok_p
= 0, zero_height_ok_p
= 0;
22108 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
22109 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
22111 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
22113 /* List should start with `space'. */
22114 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
22115 plist
= XCDR (it
->object
);
22117 /* Compute the width of the stretch. */
22118 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
22119 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
22121 /* Absolute width `:width WIDTH' specified and valid. */
22122 zero_width_ok_p
= 1;
22125 else if (prop
= Fplist_get (plist
, QCrelative_width
),
22128 /* Relative width `:relative-width FACTOR' specified and valid.
22129 Compute the width of the characters having the `glyph'
22132 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
22135 if (it
->multibyte_p
)
22136 it2
.c
= it2
.char_to_display
= STRING_CHAR_AND_LENGTH (p
, it2
.len
);
22139 it2
.c
= it2
.char_to_display
= *p
, it2
.len
= 1;
22140 if (! ASCII_CHAR_P (it2
.c
))
22141 it2
.char_to_display
= BYTE8_TO_CHAR (it2
.c
);
22144 it2
.glyph_row
= NULL
;
22145 it2
.what
= IT_CHARACTER
;
22146 x_produce_glyphs (&it2
);
22147 width
= NUMVAL (prop
) * it2
.pixel_width
;
22149 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
22150 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
22152 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
22153 align_to
= (align_to
< 0
22155 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
22156 else if (align_to
< 0)
22157 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
22158 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
22159 zero_width_ok_p
= 1;
22162 /* Nothing specified -> width defaults to canonical char width. */
22163 width
= FRAME_COLUMN_WIDTH (it
->f
);
22165 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
22168 /* Compute height. */
22169 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
22170 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
22173 zero_height_ok_p
= 1;
22175 else if (prop
= Fplist_get (plist
, QCrelative_height
),
22177 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
22179 height
= FONT_HEIGHT (font
);
22181 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
22184 /* Compute percentage of height used for ascent. If
22185 `:ascent ASCENT' is present and valid, use that. Otherwise,
22186 derive the ascent from the font in use. */
22187 if (prop
= Fplist_get (plist
, QCascent
),
22188 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
22189 ascent
= height
* NUMVAL (prop
) / 100.0;
22190 else if (!NILP (prop
)
22191 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
22192 ascent
= min (max (0, (int)tem
), height
);
22194 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
22196 if (width
> 0 && it
->line_wrap
!= TRUNCATE
22197 && it
->current_x
+ width
> it
->last_visible_x
)
22198 width
= it
->last_visible_x
- it
->current_x
- 1;
22200 if (width
> 0 && height
> 0 && it
->glyph_row
)
22202 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
22203 if (!STRINGP (object
))
22204 object
= it
->w
->buffer
;
22205 append_stretch_glyph (it
, object
, width
, height
, ascent
);
22208 it
->pixel_width
= width
;
22209 it
->ascent
= it
->phys_ascent
= ascent
;
22210 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
22211 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
22213 take_vertical_position_into_account (it
);
22216 /* Calculate line-height and line-spacing properties.
22217 An integer value specifies explicit pixel value.
22218 A float value specifies relative value to current face height.
22219 A cons (float . face-name) specifies relative value to
22220 height of specified face font.
22222 Returns height in pixels, or nil. */
22226 calc_line_height_property (struct it
*it
, Lisp_Object val
, struct font
*font
,
22227 int boff
, int override
)
22229 Lisp_Object face_name
= Qnil
;
22230 int ascent
, descent
, height
;
22232 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
22237 face_name
= XCAR (val
);
22239 if (!NUMBERP (val
))
22240 val
= make_number (1);
22241 if (NILP (face_name
))
22243 height
= it
->ascent
+ it
->descent
;
22248 if (NILP (face_name
))
22250 font
= FRAME_FONT (it
->f
);
22251 boff
= FRAME_BASELINE_OFFSET (it
->f
);
22253 else if (EQ (face_name
, Qt
))
22262 face_id
= lookup_named_face (it
->f
, face_name
, 0);
22264 return make_number (-1);
22266 face
= FACE_FROM_ID (it
->f
, face_id
);
22269 return make_number (-1);
22270 boff
= font
->baseline_offset
;
22271 if (font
->vertical_centering
)
22272 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
22275 ascent
= FONT_BASE (font
) + boff
;
22276 descent
= FONT_DESCENT (font
) - boff
;
22280 it
->override_ascent
= ascent
;
22281 it
->override_descent
= descent
;
22282 it
->override_boff
= boff
;
22285 height
= ascent
+ descent
;
22289 height
= (int)(XFLOAT_DATA (val
) * height
);
22290 else if (INTEGERP (val
))
22291 height
*= XINT (val
);
22293 return make_number (height
);
22297 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
22298 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
22299 and only if this is for a character for which no font was found.
22301 If the display method (it->glyphless_method) is
22302 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
22303 length of the acronym or the hexadecimal string, UPPER_XOFF and
22304 UPPER_YOFF are pixel offsets for the upper part of the string,
22305 LOWER_XOFF and LOWER_YOFF are for the lower part.
22307 For the other display methods, LEN through LOWER_YOFF are zero. */
22310 append_glyphless_glyph (struct it
*it
, int face_id
, int for_no_font
, int len
,
22311 short upper_xoff
, short upper_yoff
,
22312 short lower_xoff
, short lower_yoff
)
22314 struct glyph
*glyph
;
22315 enum glyph_row_area area
= it
->area
;
22317 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22318 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22320 /* If the glyph row is reversed, we need to prepend the glyph
22321 rather than append it. */
22322 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
22326 /* Make room for the additional glyph. */
22327 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
22329 glyph
= it
->glyph_row
->glyphs
[area
];
22331 glyph
->charpos
= CHARPOS (it
->position
);
22332 glyph
->object
= it
->object
;
22333 glyph
->pixel_width
= it
->pixel_width
;
22334 glyph
->ascent
= it
->ascent
;
22335 glyph
->descent
= it
->descent
;
22336 glyph
->voffset
= it
->voffset
;
22337 glyph
->type
= GLYPHLESS_GLYPH
;
22338 glyph
->u
.glyphless
.method
= it
->glyphless_method
;
22339 glyph
->u
.glyphless
.for_no_font
= for_no_font
;
22340 glyph
->u
.glyphless
.len
= len
;
22341 glyph
->u
.glyphless
.ch
= it
->c
;
22342 glyph
->slice
.glyphless
.upper_xoff
= upper_xoff
;
22343 glyph
->slice
.glyphless
.upper_yoff
= upper_yoff
;
22344 glyph
->slice
.glyphless
.lower_xoff
= lower_xoff
;
22345 glyph
->slice
.glyphless
.lower_yoff
= lower_yoff
;
22346 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22347 glyph
->multibyte_p
= it
->multibyte_p
;
22348 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22349 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22350 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
22351 || it
->phys_descent
> it
->descent
);
22352 glyph
->padding_p
= 0;
22353 glyph
->glyph_not_available_p
= 0;
22354 glyph
->face_id
= face_id
;
22355 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22358 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22359 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22361 glyph
->bidi_type
= it
->bidi_it
.type
;
22363 ++it
->glyph_row
->used
[area
];
22366 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22370 /* Produce a glyph for a glyphless character for iterator IT.
22371 IT->glyphless_method specifies which method to use for displaying
22372 the character. See the description of enum
22373 glyphless_display_method in dispextern.h for the detail.
22375 FOR_NO_FONT is nonzero if and only if this is for a character for
22376 which no font was found. ACRONYM, if non-nil, is an acronym string
22377 for the character. */
22380 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
22385 int base_width
, base_height
, width
, height
;
22386 short upper_xoff
, upper_yoff
, lower_xoff
, lower_yoff
;
22389 /* Get the metrics of the base font. We always refer to the current
22391 face
= FACE_FROM_ID (it
->f
, it
->face_id
)->ascii_face
;
22392 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
22393 it
->ascent
= FONT_BASE (font
) + font
->baseline_offset
;
22394 it
->descent
= FONT_DESCENT (font
) - font
->baseline_offset
;
22395 base_height
= it
->ascent
+ it
->descent
;
22396 base_width
= font
->average_width
;
22398 /* Get a face ID for the glyph by utilizing a cache (the same way as
22399 doen for `escape-glyph' in get_next_display_element). */
22400 if (it
->f
== last_glyphless_glyph_frame
22401 && it
->face_id
== last_glyphless_glyph_face_id
)
22403 face_id
= last_glyphless_glyph_merged_face_id
;
22407 /* Merge the `glyphless-char' face into the current face. */
22408 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
22409 last_glyphless_glyph_frame
= it
->f
;
22410 last_glyphless_glyph_face_id
= it
->face_id
;
22411 last_glyphless_glyph_merged_face_id
= face_id
;
22414 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
22416 it
->pixel_width
= THIN_SPACE_WIDTH
;
22418 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
22420 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
22422 width
= CHAR_WIDTH (it
->c
);
22425 else if (width
> 4)
22427 it
->pixel_width
= base_width
* width
;
22429 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
22435 unsigned int code
[6];
22437 int ascent
, descent
;
22438 struct font_metrics metrics_upper
, metrics_lower
;
22440 face
= FACE_FROM_ID (it
->f
, face_id
);
22441 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
22442 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
22444 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
22446 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
22447 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
22448 if (CONSP (acronym
))
22449 acronym
= XCAR (acronym
);
22450 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
22454 xassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
22455 sprintf (buf
, "%0*X", it
->c
< 0x10000 ? 4 : 6, it
->c
);
22458 for (len
= 0; str
[len
] && ASCII_BYTE_P (str
[len
]); len
++)
22459 code
[len
] = font
->driver
->encode_char (font
, str
[len
]);
22460 upper_len
= (len
+ 1) / 2;
22461 font
->driver
->text_extents (font
, code
, upper_len
,
22463 font
->driver
->text_extents (font
, code
+ upper_len
, len
- upper_len
,
22468 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
22469 width
= max (metrics_upper
.width
, metrics_lower
.width
) + 4;
22470 upper_xoff
= upper_yoff
= 2; /* the typical case */
22471 if (base_width
>= width
)
22473 /* Align the upper to the left, the lower to the right. */
22474 it
->pixel_width
= base_width
;
22475 lower_xoff
= base_width
- 2 - metrics_lower
.width
;
22479 /* Center the shorter one. */
22480 it
->pixel_width
= width
;
22481 if (metrics_upper
.width
>= metrics_lower
.width
)
22482 lower_xoff
= (width
- metrics_lower
.width
) / 2;
22485 /* FIXME: This code doesn't look right. It formerly was
22486 missing the "lower_xoff = 0;", which couldn't have
22487 been right since it left lower_xoff uninitialized. */
22489 upper_xoff
= (width
- metrics_upper
.width
) / 2;
22493 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
22494 top, bottom, and between upper and lower strings. */
22495 height
= (metrics_upper
.ascent
+ metrics_upper
.descent
22496 + metrics_lower
.ascent
+ metrics_lower
.descent
) + 5;
22497 /* Center vertically.
22498 H:base_height, D:base_descent
22499 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
22501 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
22502 descent = D - H/2 + h/2;
22503 lower_yoff = descent - 2 - ld;
22504 upper_yoff = lower_yoff - la - 1 - ud; */
22505 ascent
= - (it
->descent
- (base_height
+ height
+ 1) / 2);
22506 descent
= it
->descent
- (base_height
- height
) / 2;
22507 lower_yoff
= descent
- 2 - metrics_lower
.descent
;
22508 upper_yoff
= (lower_yoff
- metrics_lower
.ascent
- 1
22509 - metrics_upper
.descent
);
22510 /* Don't make the height shorter than the base height. */
22511 if (height
> base_height
)
22513 it
->ascent
= ascent
;
22514 it
->descent
= descent
;
22518 it
->phys_ascent
= it
->ascent
;
22519 it
->phys_descent
= it
->descent
;
22521 append_glyphless_glyph (it
, face_id
, for_no_font
, len
,
22522 upper_xoff
, upper_yoff
,
22523 lower_xoff
, lower_yoff
);
22525 take_vertical_position_into_account (it
);
22530 Produce glyphs/get display metrics for the display element IT is
22531 loaded with. See the description of struct it in dispextern.h
22532 for an overview of struct it. */
22535 x_produce_glyphs (struct it
*it
)
22537 int extra_line_spacing
= it
->extra_line_spacing
;
22539 it
->glyph_not_available_p
= 0;
22541 if (it
->what
== IT_CHARACTER
)
22544 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
22545 struct font
*font
= face
->font
;
22546 struct font_metrics
*pcm
= NULL
;
22547 int boff
; /* baseline offset */
22551 /* When no suitable font is found, display this character by
22552 the method specified in the first extra slot of
22553 Vglyphless_char_display. */
22554 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
22556 xassert (it
->what
== IT_GLYPHLESS
);
22557 produce_glyphless_glyph (it
, 1, STRINGP (acronym
) ? acronym
: Qnil
);
22561 boff
= font
->baseline_offset
;
22562 if (font
->vertical_centering
)
22563 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
22565 if (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t')
22571 if (it
->override_ascent
>= 0)
22573 it
->ascent
= it
->override_ascent
;
22574 it
->descent
= it
->override_descent
;
22575 boff
= it
->override_boff
;
22579 it
->ascent
= FONT_BASE (font
) + boff
;
22580 it
->descent
= FONT_DESCENT (font
) - boff
;
22583 if (get_char_glyph_code (it
->char_to_display
, font
, &char2b
))
22585 pcm
= get_per_char_metric (font
, &char2b
);
22586 if (pcm
->width
== 0
22587 && pcm
->rbearing
== 0 && pcm
->lbearing
== 0)
22593 it
->phys_ascent
= pcm
->ascent
+ boff
;
22594 it
->phys_descent
= pcm
->descent
- boff
;
22595 it
->pixel_width
= pcm
->width
;
22599 it
->glyph_not_available_p
= 1;
22600 it
->phys_ascent
= it
->ascent
;
22601 it
->phys_descent
= it
->descent
;
22602 it
->pixel_width
= font
->space_width
;
22605 if (it
->constrain_row_ascent_descent_p
)
22607 if (it
->descent
> it
->max_descent
)
22609 it
->ascent
+= it
->descent
- it
->max_descent
;
22610 it
->descent
= it
->max_descent
;
22612 if (it
->ascent
> it
->max_ascent
)
22614 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
22615 it
->ascent
= it
->max_ascent
;
22617 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
22618 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
22619 extra_line_spacing
= 0;
22622 /* If this is a space inside a region of text with
22623 `space-width' property, change its width. */
22624 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
22626 it
->pixel_width
*= XFLOATINT (it
->space_width
);
22628 /* If face has a box, add the box thickness to the character
22629 height. If character has a box line to the left and/or
22630 right, add the box line width to the character's width. */
22631 if (face
->box
!= FACE_NO_BOX
)
22633 int thick
= face
->box_line_width
;
22637 it
->ascent
+= thick
;
22638 it
->descent
+= thick
;
22643 if (it
->start_of_box_run_p
)
22644 it
->pixel_width
+= thick
;
22645 if (it
->end_of_box_run_p
)
22646 it
->pixel_width
+= thick
;
22649 /* If face has an overline, add the height of the overline
22650 (1 pixel) and a 1 pixel margin to the character height. */
22651 if (face
->overline_p
)
22652 it
->ascent
+= overline_margin
;
22654 if (it
->constrain_row_ascent_descent_p
)
22656 if (it
->ascent
> it
->max_ascent
)
22657 it
->ascent
= it
->max_ascent
;
22658 if (it
->descent
> it
->max_descent
)
22659 it
->descent
= it
->max_descent
;
22662 take_vertical_position_into_account (it
);
22664 /* If we have to actually produce glyphs, do it. */
22669 /* Translate a space with a `space-width' property
22670 into a stretch glyph. */
22671 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
22672 / FONT_HEIGHT (font
));
22673 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
22674 it
->ascent
+ it
->descent
, ascent
);
22679 /* If characters with lbearing or rbearing are displayed
22680 in this line, record that fact in a flag of the
22681 glyph row. This is used to optimize X output code. */
22682 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
22683 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
22685 if (! stretched_p
&& it
->pixel_width
== 0)
22686 /* We assure that all visible glyphs have at least 1-pixel
22688 it
->pixel_width
= 1;
22690 else if (it
->char_to_display
== '\n')
22692 /* A newline has no width, but we need the height of the
22693 line. But if previous part of the line sets a height,
22694 don't increase that height */
22696 Lisp_Object height
;
22697 Lisp_Object total_height
= Qnil
;
22699 it
->override_ascent
= -1;
22700 it
->pixel_width
= 0;
22703 height
= get_it_property (it
, Qline_height
);
22704 /* Split (line-height total-height) list */
22706 && CONSP (XCDR (height
))
22707 && NILP (XCDR (XCDR (height
))))
22709 total_height
= XCAR (XCDR (height
));
22710 height
= XCAR (height
);
22712 height
= calc_line_height_property (it
, height
, font
, boff
, 1);
22714 if (it
->override_ascent
>= 0)
22716 it
->ascent
= it
->override_ascent
;
22717 it
->descent
= it
->override_descent
;
22718 boff
= it
->override_boff
;
22722 it
->ascent
= FONT_BASE (font
) + boff
;
22723 it
->descent
= FONT_DESCENT (font
) - boff
;
22726 if (EQ (height
, Qt
))
22728 if (it
->descent
> it
->max_descent
)
22730 it
->ascent
+= it
->descent
- it
->max_descent
;
22731 it
->descent
= it
->max_descent
;
22733 if (it
->ascent
> it
->max_ascent
)
22735 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
22736 it
->ascent
= it
->max_ascent
;
22738 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
22739 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
22740 it
->constrain_row_ascent_descent_p
= 1;
22741 extra_line_spacing
= 0;
22745 Lisp_Object spacing
;
22747 it
->phys_ascent
= it
->ascent
;
22748 it
->phys_descent
= it
->descent
;
22750 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
22751 && face
->box
!= FACE_NO_BOX
22752 && face
->box_line_width
> 0)
22754 it
->ascent
+= face
->box_line_width
;
22755 it
->descent
+= face
->box_line_width
;
22758 && XINT (height
) > it
->ascent
+ it
->descent
)
22759 it
->ascent
= XINT (height
) - it
->descent
;
22761 if (!NILP (total_height
))
22762 spacing
= calc_line_height_property (it
, total_height
, font
, boff
, 0);
22765 spacing
= get_it_property (it
, Qline_spacing
);
22766 spacing
= calc_line_height_property (it
, spacing
, font
, boff
, 0);
22768 if (INTEGERP (spacing
))
22770 extra_line_spacing
= XINT (spacing
);
22771 if (!NILP (total_height
))
22772 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
22776 else /* i.e. (it->char_to_display == '\t') */
22778 if (font
->space_width
> 0)
22780 int tab_width
= it
->tab_width
* font
->space_width
;
22781 int x
= it
->current_x
+ it
->continuation_lines_width
;
22782 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
22784 /* If the distance from the current position to the next tab
22785 stop is less than a space character width, use the
22786 tab stop after that. */
22787 if (next_tab_x
- x
< font
->space_width
)
22788 next_tab_x
+= tab_width
;
22790 it
->pixel_width
= next_tab_x
- x
;
22792 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
22793 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
22797 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
22798 it
->ascent
+ it
->descent
, it
->ascent
);
22803 it
->pixel_width
= 0;
22808 else if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
< 0)
22810 /* A static composition.
22812 Note: A composition is represented as one glyph in the
22813 glyph matrix. There are no padding glyphs.
22815 Important note: pixel_width, ascent, and descent are the
22816 values of what is drawn by draw_glyphs (i.e. the values of
22817 the overall glyphs composed). */
22818 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
22819 int boff
; /* baseline offset */
22820 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
22821 int glyph_len
= cmp
->glyph_len
;
22822 struct font
*font
= face
->font
;
22826 /* If we have not yet calculated pixel size data of glyphs of
22827 the composition for the current face font, calculate them
22828 now. Theoretically, we have to check all fonts for the
22829 glyphs, but that requires much time and memory space. So,
22830 here we check only the font of the first glyph. This may
22831 lead to incorrect display, but it's very rare, and C-l
22832 (recenter-top-bottom) can correct the display anyway. */
22833 if (! cmp
->font
|| cmp
->font
!= font
)
22835 /* Ascent and descent of the font of the first character
22836 of this composition (adjusted by baseline offset).
22837 Ascent and descent of overall glyphs should not be less
22838 than these, respectively. */
22839 int font_ascent
, font_descent
, font_height
;
22840 /* Bounding box of the overall glyphs. */
22841 int leftmost
, rightmost
, lowest
, highest
;
22842 int lbearing
, rbearing
;
22843 int i
, width
, ascent
, descent
;
22844 int left_padded
= 0, right_padded
= 0;
22845 int c
IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
22847 struct font_metrics
*pcm
;
22848 int font_not_found_p
;
22851 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
22852 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
22854 if (glyph_len
< cmp
->glyph_len
)
22856 for (i
= 0; i
< glyph_len
; i
++)
22858 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
22860 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
22865 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
22866 : IT_CHARPOS (*it
));
22867 /* If no suitable font is found, use the default font. */
22868 font_not_found_p
= font
== NULL
;
22869 if (font_not_found_p
)
22871 face
= face
->ascii_face
;
22874 boff
= font
->baseline_offset
;
22875 if (font
->vertical_centering
)
22876 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
22877 font_ascent
= FONT_BASE (font
) + boff
;
22878 font_descent
= FONT_DESCENT (font
) - boff
;
22879 font_height
= FONT_HEIGHT (font
);
22881 cmp
->font
= (void *) font
;
22884 if (! font_not_found_p
)
22886 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
22888 pcm
= get_per_char_metric (font
, &char2b
);
22891 /* Initialize the bounding box. */
22894 width
= pcm
->width
;
22895 ascent
= pcm
->ascent
;
22896 descent
= pcm
->descent
;
22897 lbearing
= pcm
->lbearing
;
22898 rbearing
= pcm
->rbearing
;
22902 width
= font
->space_width
;
22903 ascent
= FONT_BASE (font
);
22904 descent
= FONT_DESCENT (font
);
22911 lowest
= - descent
+ boff
;
22912 highest
= ascent
+ boff
;
22914 if (! font_not_found_p
22915 && font
->default_ascent
22916 && CHAR_TABLE_P (Vuse_default_ascent
)
22917 && !NILP (Faref (Vuse_default_ascent
,
22918 make_number (it
->char_to_display
))))
22919 highest
= font
->default_ascent
+ boff
;
22921 /* Draw the first glyph at the normal position. It may be
22922 shifted to right later if some other glyphs are drawn
22924 cmp
->offsets
[i
* 2] = 0;
22925 cmp
->offsets
[i
* 2 + 1] = boff
;
22926 cmp
->lbearing
= lbearing
;
22927 cmp
->rbearing
= rbearing
;
22929 /* Set cmp->offsets for the remaining glyphs. */
22930 for (i
++; i
< glyph_len
; i
++)
22932 int left
, right
, btm
, top
;
22933 int ch
= COMPOSITION_GLYPH (cmp
, i
);
22935 struct face
*this_face
;
22939 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
22940 this_face
= FACE_FROM_ID (it
->f
, face_id
);
22941 font
= this_face
->font
;
22947 get_char_face_and_encoding (it
->f
, ch
, face_id
,
22949 pcm
= get_per_char_metric (font
, &char2b
);
22952 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
22955 width
= pcm
->width
;
22956 ascent
= pcm
->ascent
;
22957 descent
= pcm
->descent
;
22958 lbearing
= pcm
->lbearing
;
22959 rbearing
= pcm
->rbearing
;
22960 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
22962 /* Relative composition with or without
22963 alternate chars. */
22964 left
= (leftmost
+ rightmost
- width
) / 2;
22965 btm
= - descent
+ boff
;
22966 if (font
->relative_compose
22967 && (! CHAR_TABLE_P (Vignore_relative_composition
)
22968 || NILP (Faref (Vignore_relative_composition
,
22969 make_number (ch
)))))
22972 if (- descent
>= font
->relative_compose
)
22973 /* One extra pixel between two glyphs. */
22975 else if (ascent
<= 0)
22976 /* One extra pixel between two glyphs. */
22977 btm
= lowest
- 1 - ascent
- descent
;
22982 /* A composition rule is specified by an integer
22983 value that encodes global and new reference
22984 points (GREF and NREF). GREF and NREF are
22985 specified by numbers as below:
22987 0---1---2 -- ascent
22991 9--10--11 -- center
22993 ---3---4---5--- baseline
22995 6---7---8 -- descent
22997 int rule
= COMPOSITION_RULE (cmp
, i
);
22998 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
23000 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
23001 grefx
= gref
% 3, nrefx
= nref
% 3;
23002 grefy
= gref
/ 3, nrefy
= nref
/ 3;
23004 xoff
= font_height
* (xoff
- 128) / 256;
23006 yoff
= font_height
* (yoff
- 128) / 256;
23009 + grefx
* (rightmost
- leftmost
) / 2
23010 - nrefx
* width
/ 2
23013 btm
= ((grefy
== 0 ? highest
23015 : grefy
== 2 ? lowest
23016 : (highest
+ lowest
) / 2)
23017 - (nrefy
== 0 ? ascent
+ descent
23018 : nrefy
== 1 ? descent
- boff
23020 : (ascent
+ descent
) / 2)
23024 cmp
->offsets
[i
* 2] = left
;
23025 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
23027 /* Update the bounding box of the overall glyphs. */
23030 right
= left
+ width
;
23031 if (left
< leftmost
)
23033 if (right
> rightmost
)
23036 top
= btm
+ descent
+ ascent
;
23042 if (cmp
->lbearing
> left
+ lbearing
)
23043 cmp
->lbearing
= left
+ lbearing
;
23044 if (cmp
->rbearing
< left
+ rbearing
)
23045 cmp
->rbearing
= left
+ rbearing
;
23049 /* If there are glyphs whose x-offsets are negative,
23050 shift all glyphs to the right and make all x-offsets
23054 for (i
= 0; i
< cmp
->glyph_len
; i
++)
23055 cmp
->offsets
[i
* 2] -= leftmost
;
23056 rightmost
-= leftmost
;
23057 cmp
->lbearing
-= leftmost
;
23058 cmp
->rbearing
-= leftmost
;
23061 if (left_padded
&& cmp
->lbearing
< 0)
23063 for (i
= 0; i
< cmp
->glyph_len
; i
++)
23064 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
23065 rightmost
-= cmp
->lbearing
;
23066 cmp
->rbearing
-= cmp
->lbearing
;
23069 if (right_padded
&& rightmost
< cmp
->rbearing
)
23071 rightmost
= cmp
->rbearing
;
23074 cmp
->pixel_width
= rightmost
;
23075 cmp
->ascent
= highest
;
23076 cmp
->descent
= - lowest
;
23077 if (cmp
->ascent
< font_ascent
)
23078 cmp
->ascent
= font_ascent
;
23079 if (cmp
->descent
< font_descent
)
23080 cmp
->descent
= font_descent
;
23084 && (cmp
->lbearing
< 0
23085 || cmp
->rbearing
> cmp
->pixel_width
))
23086 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
23088 it
->pixel_width
= cmp
->pixel_width
;
23089 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
23090 it
->descent
= it
->phys_descent
= cmp
->descent
;
23091 if (face
->box
!= FACE_NO_BOX
)
23093 int thick
= face
->box_line_width
;
23097 it
->ascent
+= thick
;
23098 it
->descent
+= thick
;
23103 if (it
->start_of_box_run_p
)
23104 it
->pixel_width
+= thick
;
23105 if (it
->end_of_box_run_p
)
23106 it
->pixel_width
+= thick
;
23109 /* If face has an overline, add the height of the overline
23110 (1 pixel) and a 1 pixel margin to the character height. */
23111 if (face
->overline_p
)
23112 it
->ascent
+= overline_margin
;
23114 take_vertical_position_into_account (it
);
23115 if (it
->ascent
< 0)
23117 if (it
->descent
< 0)
23121 append_composite_glyph (it
);
23123 else if (it
->what
== IT_COMPOSITION
)
23125 /* A dynamic (automatic) composition. */
23126 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23127 Lisp_Object gstring
;
23128 struct font_metrics metrics
;
23130 gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
23132 = composition_gstring_width (gstring
, it
->cmp_it
.from
, it
->cmp_it
.to
,
23135 && (metrics
.lbearing
< 0 || metrics
.rbearing
> metrics
.width
))
23136 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
23137 it
->ascent
= it
->phys_ascent
= metrics
.ascent
;
23138 it
->descent
= it
->phys_descent
= metrics
.descent
;
23139 if (face
->box
!= FACE_NO_BOX
)
23141 int thick
= face
->box_line_width
;
23145 it
->ascent
+= thick
;
23146 it
->descent
+= thick
;
23151 if (it
->start_of_box_run_p
)
23152 it
->pixel_width
+= thick
;
23153 if (it
->end_of_box_run_p
)
23154 it
->pixel_width
+= thick
;
23156 /* If face has an overline, add the height of the overline
23157 (1 pixel) and a 1 pixel margin to the character height. */
23158 if (face
->overline_p
)
23159 it
->ascent
+= overline_margin
;
23160 take_vertical_position_into_account (it
);
23161 if (it
->ascent
< 0)
23163 if (it
->descent
< 0)
23167 append_composite_glyph (it
);
23169 else if (it
->what
== IT_GLYPHLESS
)
23170 produce_glyphless_glyph (it
, 0, Qnil
);
23171 else if (it
->what
== IT_IMAGE
)
23172 produce_image_glyph (it
);
23173 else if (it
->what
== IT_STRETCH
)
23174 produce_stretch_glyph (it
);
23177 /* Accumulate dimensions. Note: can't assume that it->descent > 0
23178 because this isn't true for images with `:ascent 100'. */
23179 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
23180 if (it
->area
== TEXT_AREA
)
23181 it
->current_x
+= it
->pixel_width
;
23183 if (extra_line_spacing
> 0)
23185 it
->descent
+= extra_line_spacing
;
23186 if (extra_line_spacing
> it
->max_extra_line_spacing
)
23187 it
->max_extra_line_spacing
= extra_line_spacing
;
23190 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
23191 it
->max_descent
= max (it
->max_descent
, it
->descent
);
23192 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
23193 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
23197 Output LEN glyphs starting at START at the nominal cursor position.
23198 Advance the nominal cursor over the text. The global variable
23199 updated_window contains the window being updated, updated_row is
23200 the glyph row being updated, and updated_area is the area of that
23201 row being updated. */
23204 x_write_glyphs (struct glyph
*start
, int len
)
23208 xassert (updated_window
&& updated_row
);
23211 /* Write glyphs. */
23213 hpos
= start
- updated_row
->glyphs
[updated_area
];
23214 x
= draw_glyphs (updated_window
, output_cursor
.x
,
23215 updated_row
, updated_area
,
23217 DRAW_NORMAL_TEXT
, 0);
23219 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
23220 if (updated_area
== TEXT_AREA
23221 && updated_window
->phys_cursor_on_p
23222 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
23223 && updated_window
->phys_cursor
.hpos
>= hpos
23224 && updated_window
->phys_cursor
.hpos
< hpos
+ len
)
23225 updated_window
->phys_cursor_on_p
= 0;
23229 /* Advance the output cursor. */
23230 output_cursor
.hpos
+= len
;
23231 output_cursor
.x
= x
;
23236 Insert LEN glyphs from START at the nominal cursor position. */
23239 x_insert_glyphs (struct glyph
*start
, int len
)
23243 int line_height
, shift_by_width
, shifted_region_width
;
23244 struct glyph_row
*row
;
23245 struct glyph
*glyph
;
23246 int frame_x
, frame_y
;
23249 xassert (updated_window
&& updated_row
);
23251 w
= updated_window
;
23252 f
= XFRAME (WINDOW_FRAME (w
));
23254 /* Get the height of the line we are in. */
23256 line_height
= row
->height
;
23258 /* Get the width of the glyphs to insert. */
23259 shift_by_width
= 0;
23260 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
23261 shift_by_width
+= glyph
->pixel_width
;
23263 /* Get the width of the region to shift right. */
23264 shifted_region_width
= (window_box_width (w
, updated_area
)
23269 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
23270 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
23272 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
23273 line_height
, shift_by_width
);
23275 /* Write the glyphs. */
23276 hpos
= start
- row
->glyphs
[updated_area
];
23277 draw_glyphs (w
, output_cursor
.x
, row
, updated_area
,
23279 DRAW_NORMAL_TEXT
, 0);
23281 /* Advance the output cursor. */
23282 output_cursor
.hpos
+= len
;
23283 output_cursor
.x
+= shift_by_width
;
23289 Erase the current text line from the nominal cursor position
23290 (inclusive) to pixel column TO_X (exclusive). The idea is that
23291 everything from TO_X onward is already erased.
23293 TO_X is a pixel position relative to updated_area of
23294 updated_window. TO_X == -1 means clear to the end of this area. */
23297 x_clear_end_of_line (int to_x
)
23300 struct window
*w
= updated_window
;
23301 int max_x
, min_y
, max_y
;
23302 int from_x
, from_y
, to_y
;
23304 xassert (updated_window
&& updated_row
);
23305 f
= XFRAME (w
->frame
);
23307 if (updated_row
->full_width_p
)
23308 max_x
= WINDOW_TOTAL_WIDTH (w
);
23310 max_x
= window_box_width (w
, updated_area
);
23311 max_y
= window_text_bottom_y (w
);
23313 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
23314 of window. For TO_X > 0, truncate to end of drawing area. */
23320 to_x
= min (to_x
, max_x
);
23322 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
23324 /* Notice if the cursor will be cleared by this operation. */
23325 if (!updated_row
->full_width_p
)
23326 notice_overwritten_cursor (w
, updated_area
,
23327 output_cursor
.x
, -1,
23329 MATRIX_ROW_BOTTOM_Y (updated_row
));
23331 from_x
= output_cursor
.x
;
23333 /* Translate to frame coordinates. */
23334 if (updated_row
->full_width_p
)
23336 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
23337 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
23341 int area_left
= window_box_left (w
, updated_area
);
23342 from_x
+= area_left
;
23346 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
23347 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
23348 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
23350 /* Prevent inadvertently clearing to end of the X window. */
23351 if (to_x
> from_x
&& to_y
> from_y
)
23354 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
23355 to_x
- from_x
, to_y
- from_y
);
23360 #endif /* HAVE_WINDOW_SYSTEM */
23364 /***********************************************************************
23366 ***********************************************************************/
23368 /* Value is the internal representation of the specified cursor type
23369 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
23370 of the bar cursor. */
23372 static enum text_cursor_kinds
23373 get_specified_cursor_type (Lisp_Object arg
, int *width
)
23375 enum text_cursor_kinds type
;
23380 if (EQ (arg
, Qbox
))
23381 return FILLED_BOX_CURSOR
;
23383 if (EQ (arg
, Qhollow
))
23384 return HOLLOW_BOX_CURSOR
;
23386 if (EQ (arg
, Qbar
))
23393 && EQ (XCAR (arg
), Qbar
)
23394 && INTEGERP (XCDR (arg
))
23395 && XINT (XCDR (arg
)) >= 0)
23397 *width
= XINT (XCDR (arg
));
23401 if (EQ (arg
, Qhbar
))
23404 return HBAR_CURSOR
;
23408 && EQ (XCAR (arg
), Qhbar
)
23409 && INTEGERP (XCDR (arg
))
23410 && XINT (XCDR (arg
)) >= 0)
23412 *width
= XINT (XCDR (arg
));
23413 return HBAR_CURSOR
;
23416 /* Treat anything unknown as "hollow box cursor".
23417 It was bad to signal an error; people have trouble fixing
23418 .Xdefaults with Emacs, when it has something bad in it. */
23419 type
= HOLLOW_BOX_CURSOR
;
23424 /* Set the default cursor types for specified frame. */
23426 set_frame_cursor_types (struct frame
*f
, Lisp_Object arg
)
23431 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
23432 FRAME_CURSOR_WIDTH (f
) = width
;
23434 /* By default, set up the blink-off state depending on the on-state. */
23436 tem
= Fassoc (arg
, Vblink_cursor_alist
);
23439 FRAME_BLINK_OFF_CURSOR (f
)
23440 = get_specified_cursor_type (XCDR (tem
), &width
);
23441 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
23444 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
23448 #ifdef HAVE_WINDOW_SYSTEM
23450 /* Return the cursor we want to be displayed in window W. Return
23451 width of bar/hbar cursor through WIDTH arg. Return with
23452 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
23453 (i.e. if the `system caret' should track this cursor).
23455 In a mini-buffer window, we want the cursor only to appear if we
23456 are reading input from this window. For the selected window, we
23457 want the cursor type given by the frame parameter or buffer local
23458 setting of cursor-type. If explicitly marked off, draw no cursor.
23459 In all other cases, we want a hollow box cursor. */
23461 static enum text_cursor_kinds
23462 get_window_cursor_type (struct window
*w
, struct glyph
*glyph
, int *width
,
23463 int *active_cursor
)
23465 struct frame
*f
= XFRAME (w
->frame
);
23466 struct buffer
*b
= XBUFFER (w
->buffer
);
23467 int cursor_type
= DEFAULT_CURSOR
;
23468 Lisp_Object alt_cursor
;
23469 int non_selected
= 0;
23471 *active_cursor
= 1;
23474 if (cursor_in_echo_area
23475 && FRAME_HAS_MINIBUF_P (f
)
23476 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
23478 if (w
== XWINDOW (echo_area_window
))
23480 if (EQ (BVAR (b
, cursor_type
), Qt
) || NILP (BVAR (b
, cursor_type
)))
23482 *width
= FRAME_CURSOR_WIDTH (f
);
23483 return FRAME_DESIRED_CURSOR (f
);
23486 return get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
23489 *active_cursor
= 0;
23493 /* Detect a nonselected window or nonselected frame. */
23494 else if (w
!= XWINDOW (f
->selected_window
)
23495 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
23497 *active_cursor
= 0;
23499 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
23505 /* Never display a cursor in a window in which cursor-type is nil. */
23506 if (NILP (BVAR (b
, cursor_type
)))
23509 /* Get the normal cursor type for this window. */
23510 if (EQ (BVAR (b
, cursor_type
), Qt
))
23512 cursor_type
= FRAME_DESIRED_CURSOR (f
);
23513 *width
= FRAME_CURSOR_WIDTH (f
);
23516 cursor_type
= get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
23518 /* Use cursor-in-non-selected-windows instead
23519 for non-selected window or frame. */
23522 alt_cursor
= BVAR (b
, cursor_in_non_selected_windows
);
23523 if (!EQ (Qt
, alt_cursor
))
23524 return get_specified_cursor_type (alt_cursor
, width
);
23525 /* t means modify the normal cursor type. */
23526 if (cursor_type
== FILLED_BOX_CURSOR
)
23527 cursor_type
= HOLLOW_BOX_CURSOR
;
23528 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
23530 return cursor_type
;
23533 /* Use normal cursor if not blinked off. */
23534 if (!w
->cursor_off_p
)
23536 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
23538 if (cursor_type
== FILLED_BOX_CURSOR
)
23540 /* Using a block cursor on large images can be very annoying.
23541 So use a hollow cursor for "large" images.
23542 If image is not transparent (no mask), also use hollow cursor. */
23543 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
23544 if (img
!= NULL
&& IMAGEP (img
->spec
))
23546 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
23547 where N = size of default frame font size.
23548 This should cover most of the "tiny" icons people may use. */
23550 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
23551 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
23552 cursor_type
= HOLLOW_BOX_CURSOR
;
23555 else if (cursor_type
!= NO_CURSOR
)
23557 /* Display current only supports BOX and HOLLOW cursors for images.
23558 So for now, unconditionally use a HOLLOW cursor when cursor is
23559 not a solid box cursor. */
23560 cursor_type
= HOLLOW_BOX_CURSOR
;
23563 return cursor_type
;
23566 /* Cursor is blinked off, so determine how to "toggle" it. */
23568 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
23569 if ((alt_cursor
= Fassoc (BVAR (b
, cursor_type
), Vblink_cursor_alist
), !NILP (alt_cursor
)))
23570 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
23572 /* Then see if frame has specified a specific blink off cursor type. */
23573 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
23575 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
23576 return FRAME_BLINK_OFF_CURSOR (f
);
23580 /* Some people liked having a permanently visible blinking cursor,
23581 while others had very strong opinions against it. So it was
23582 decided to remove it. KFS 2003-09-03 */
23584 /* Finally perform built-in cursor blinking:
23585 filled box <-> hollow box
23586 wide [h]bar <-> narrow [h]bar
23587 narrow [h]bar <-> no cursor
23588 other type <-> no cursor */
23590 if (cursor_type
== FILLED_BOX_CURSOR
)
23591 return HOLLOW_BOX_CURSOR
;
23593 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
23596 return cursor_type
;
23604 /* Notice when the text cursor of window W has been completely
23605 overwritten by a drawing operation that outputs glyphs in AREA
23606 starting at X0 and ending at X1 in the line starting at Y0 and
23607 ending at Y1. X coordinates are area-relative. X1 < 0 means all
23608 the rest of the line after X0 has been written. Y coordinates
23609 are window-relative. */
23612 notice_overwritten_cursor (struct window
*w
, enum glyph_row_area area
,
23613 int x0
, int x1
, int y0
, int y1
)
23615 int cx0
, cx1
, cy0
, cy1
;
23616 struct glyph_row
*row
;
23618 if (!w
->phys_cursor_on_p
)
23620 if (area
!= TEXT_AREA
)
23623 if (w
->phys_cursor
.vpos
< 0
23624 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
23625 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
23626 !(row
->enabled_p
&& row
->displays_text_p
)))
23629 if (row
->cursor_in_fringe_p
)
23631 row
->cursor_in_fringe_p
= 0;
23632 draw_fringe_bitmap (w
, row
, row
->reversed_p
);
23633 w
->phys_cursor_on_p
= 0;
23637 cx0
= w
->phys_cursor
.x
;
23638 cx1
= cx0
+ w
->phys_cursor_width
;
23639 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
23642 /* The cursor image will be completely removed from the
23643 screen if the output area intersects the cursor area in
23644 y-direction. When we draw in [y0 y1[, and some part of
23645 the cursor is at y < y0, that part must have been drawn
23646 before. When scrolling, the cursor is erased before
23647 actually scrolling, so we don't come here. When not
23648 scrolling, the rows above the old cursor row must have
23649 changed, and in this case these rows must have written
23650 over the cursor image.
23652 Likewise if part of the cursor is below y1, with the
23653 exception of the cursor being in the first blank row at
23654 the buffer and window end because update_text_area
23655 doesn't draw that row. (Except when it does, but
23656 that's handled in update_text_area.) */
23658 cy0
= w
->phys_cursor
.y
;
23659 cy1
= cy0
+ w
->phys_cursor_height
;
23660 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
23663 w
->phys_cursor_on_p
= 0;
23666 #endif /* HAVE_WINDOW_SYSTEM */
23669 /************************************************************************
23671 ************************************************************************/
23673 #ifdef HAVE_WINDOW_SYSTEM
23676 Fix the display of area AREA of overlapping row ROW in window W
23677 with respect to the overlapping part OVERLAPS. */
23680 x_fix_overlapping_area (struct window
*w
, struct glyph_row
*row
,
23681 enum glyph_row_area area
, int overlaps
)
23688 for (i
= 0; i
< row
->used
[area
];)
23690 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
23692 int start
= i
, start_x
= x
;
23696 x
+= row
->glyphs
[area
][i
].pixel_width
;
23699 while (i
< row
->used
[area
]
23700 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
23702 draw_glyphs (w
, start_x
, row
, area
,
23704 DRAW_NORMAL_TEXT
, overlaps
);
23708 x
+= row
->glyphs
[area
][i
].pixel_width
;
23718 Draw the cursor glyph of window W in glyph row ROW. See the
23719 comment of draw_glyphs for the meaning of HL. */
23722 draw_phys_cursor_glyph (struct window
*w
, struct glyph_row
*row
,
23723 enum draw_glyphs_face hl
)
23725 /* If cursor hpos is out of bounds, don't draw garbage. This can
23726 happen in mini-buffer windows when switching between echo area
23727 glyphs and mini-buffer. */
23728 if ((row
->reversed_p
23729 ? (w
->phys_cursor
.hpos
>= 0)
23730 : (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])))
23732 int on_p
= w
->phys_cursor_on_p
;
23734 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
23735 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
23737 w
->phys_cursor_on_p
= on_p
;
23739 if (hl
== DRAW_CURSOR
)
23740 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
23741 /* When we erase the cursor, and ROW is overlapped by other
23742 rows, make sure that these overlapping parts of other rows
23744 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
23746 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
23748 if (row
> w
->current_matrix
->rows
23749 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
23750 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
23751 OVERLAPS_ERASED_CURSOR
);
23753 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
23754 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
23755 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
23756 OVERLAPS_ERASED_CURSOR
);
23763 Erase the image of a cursor of window W from the screen. */
23766 erase_phys_cursor (struct window
*w
)
23768 struct frame
*f
= XFRAME (w
->frame
);
23769 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
23770 int hpos
= w
->phys_cursor
.hpos
;
23771 int vpos
= w
->phys_cursor
.vpos
;
23772 int mouse_face_here_p
= 0;
23773 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
23774 struct glyph_row
*cursor_row
;
23775 struct glyph
*cursor_glyph
;
23776 enum draw_glyphs_face hl
;
23778 /* No cursor displayed or row invalidated => nothing to do on the
23780 if (w
->phys_cursor_type
== NO_CURSOR
)
23781 goto mark_cursor_off
;
23783 /* VPOS >= active_glyphs->nrows means that window has been resized.
23784 Don't bother to erase the cursor. */
23785 if (vpos
>= active_glyphs
->nrows
)
23786 goto mark_cursor_off
;
23788 /* If row containing cursor is marked invalid, there is nothing we
23790 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
23791 if (!cursor_row
->enabled_p
)
23792 goto mark_cursor_off
;
23794 /* If line spacing is > 0, old cursor may only be partially visible in
23795 window after split-window. So adjust visible height. */
23796 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
23797 window_text_bottom_y (w
) - cursor_row
->y
);
23799 /* If row is completely invisible, don't attempt to delete a cursor which
23800 isn't there. This can happen if cursor is at top of a window, and
23801 we switch to a buffer with a header line in that window. */
23802 if (cursor_row
->visible_height
<= 0)
23803 goto mark_cursor_off
;
23805 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
23806 if (cursor_row
->cursor_in_fringe_p
)
23808 cursor_row
->cursor_in_fringe_p
= 0;
23809 draw_fringe_bitmap (w
, cursor_row
, cursor_row
->reversed_p
);
23810 goto mark_cursor_off
;
23813 /* This can happen when the new row is shorter than the old one.
23814 In this case, either draw_glyphs or clear_end_of_line
23815 should have cleared the cursor. Note that we wouldn't be
23816 able to erase the cursor in this case because we don't have a
23817 cursor glyph at hand. */
23818 if ((cursor_row
->reversed_p
23819 ? (w
->phys_cursor
.hpos
< 0)
23820 : (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])))
23821 goto mark_cursor_off
;
23823 /* If the cursor is in the mouse face area, redisplay that when
23824 we clear the cursor. */
23825 if (! NILP (hlinfo
->mouse_face_window
)
23826 && coords_in_mouse_face_p (w
, hpos
, vpos
)
23827 /* Don't redraw the cursor's spot in mouse face if it is at the
23828 end of a line (on a newline). The cursor appears there, but
23829 mouse highlighting does not. */
23830 && cursor_row
->used
[TEXT_AREA
] > hpos
&& hpos
>= 0)
23831 mouse_face_here_p
= 1;
23833 /* Maybe clear the display under the cursor. */
23834 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
23837 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
23840 cursor_glyph
= get_phys_cursor_glyph (w
);
23841 if (cursor_glyph
== NULL
)
23842 goto mark_cursor_off
;
23844 width
= cursor_glyph
->pixel_width
;
23845 left_x
= window_box_left_offset (w
, TEXT_AREA
);
23846 x
= w
->phys_cursor
.x
;
23848 width
-= left_x
- x
;
23849 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
23850 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
23851 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
23854 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
23857 /* Erase the cursor by redrawing the character underneath it. */
23858 if (mouse_face_here_p
)
23859 hl
= DRAW_MOUSE_FACE
;
23861 hl
= DRAW_NORMAL_TEXT
;
23862 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
23865 w
->phys_cursor_on_p
= 0;
23866 w
->phys_cursor_type
= NO_CURSOR
;
23871 Display or clear cursor of window W. If ON is zero, clear the
23872 cursor. If it is non-zero, display the cursor. If ON is nonzero,
23873 where to put the cursor is specified by HPOS, VPOS, X and Y. */
23876 display_and_set_cursor (struct window
*w
, int on
,
23877 int hpos
, int vpos
, int x
, int y
)
23879 struct frame
*f
= XFRAME (w
->frame
);
23880 int new_cursor_type
;
23881 int new_cursor_width
;
23883 struct glyph_row
*glyph_row
;
23884 struct glyph
*glyph
;
23886 /* This is pointless on invisible frames, and dangerous on garbaged
23887 windows and frames; in the latter case, the frame or window may
23888 be in the midst of changing its size, and x and y may be off the
23890 if (! FRAME_VISIBLE_P (f
)
23891 || FRAME_GARBAGED_P (f
)
23892 || vpos
>= w
->current_matrix
->nrows
23893 || hpos
>= w
->current_matrix
->matrix_w
)
23896 /* If cursor is off and we want it off, return quickly. */
23897 if (!on
&& !w
->phys_cursor_on_p
)
23900 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
23901 /* If cursor row is not enabled, we don't really know where to
23902 display the cursor. */
23903 if (!glyph_row
->enabled_p
)
23905 w
->phys_cursor_on_p
= 0;
23910 if (!glyph_row
->exact_window_width_line_p
23911 || (0 <= hpos
&& hpos
< glyph_row
->used
[TEXT_AREA
]))
23912 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
23914 xassert (interrupt_input_blocked
);
23916 /* Set new_cursor_type to the cursor we want to be displayed. */
23917 new_cursor_type
= get_window_cursor_type (w
, glyph
,
23918 &new_cursor_width
, &active_cursor
);
23920 /* If cursor is currently being shown and we don't want it to be or
23921 it is in the wrong place, or the cursor type is not what we want,
23923 if (w
->phys_cursor_on_p
23925 || w
->phys_cursor
.x
!= x
23926 || w
->phys_cursor
.y
!= y
23927 || new_cursor_type
!= w
->phys_cursor_type
23928 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
23929 && new_cursor_width
!= w
->phys_cursor_width
)))
23930 erase_phys_cursor (w
);
23932 /* Don't check phys_cursor_on_p here because that flag is only set
23933 to zero in some cases where we know that the cursor has been
23934 completely erased, to avoid the extra work of erasing the cursor
23935 twice. In other words, phys_cursor_on_p can be 1 and the cursor
23936 still not be visible, or it has only been partly erased. */
23939 w
->phys_cursor_ascent
= glyph_row
->ascent
;
23940 w
->phys_cursor_height
= glyph_row
->height
;
23942 /* Set phys_cursor_.* before x_draw_.* is called because some
23943 of them may need the information. */
23944 w
->phys_cursor
.x
= x
;
23945 w
->phys_cursor
.y
= glyph_row
->y
;
23946 w
->phys_cursor
.hpos
= hpos
;
23947 w
->phys_cursor
.vpos
= vpos
;
23950 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
23951 new_cursor_type
, new_cursor_width
,
23952 on
, active_cursor
);
23956 /* Switch the display of W's cursor on or off, according to the value
23960 update_window_cursor (struct window
*w
, int on
)
23962 /* Don't update cursor in windows whose frame is in the process
23963 of being deleted. */
23964 if (w
->current_matrix
)
23967 display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
23968 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
23974 /* Call update_window_cursor with parameter ON_P on all leaf windows
23975 in the window tree rooted at W. */
23978 update_cursor_in_window_tree (struct window
*w
, int on_p
)
23982 if (!NILP (w
->hchild
))
23983 update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
23984 else if (!NILP (w
->vchild
))
23985 update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
23987 update_window_cursor (w
, on_p
);
23989 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
23995 Display the cursor on window W, or clear it, according to ON_P.
23996 Don't change the cursor's position. */
23999 x_update_cursor (struct frame
*f
, int on_p
)
24001 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
24006 Clear the cursor of window W to background color, and mark the
24007 cursor as not shown. This is used when the text where the cursor
24008 is about to be rewritten. */
24011 x_clear_cursor (struct window
*w
)
24013 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
24014 update_window_cursor (w
, 0);
24017 #endif /* HAVE_WINDOW_SYSTEM */
24019 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
24022 draw_row_with_mouse_face (struct window
*w
, int start_x
, struct glyph_row
*row
,
24023 int start_hpos
, int end_hpos
,
24024 enum draw_glyphs_face draw
)
24026 #ifdef HAVE_WINDOW_SYSTEM
24027 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
24029 draw_glyphs (w
, start_x
, row
, TEXT_AREA
, start_hpos
, end_hpos
, draw
, 0);
24033 #if defined (HAVE_GPM) || defined (MSDOS)
24034 tty_draw_row_with_mouse_face (w
, row
, start_hpos
, end_hpos
, draw
);
24038 /* Display the active region described by mouse_face_* according to DRAW. */
24041 show_mouse_face (Mouse_HLInfo
*hlinfo
, enum draw_glyphs_face draw
)
24043 struct window
*w
= XWINDOW (hlinfo
->mouse_face_window
);
24044 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
24046 if (/* If window is in the process of being destroyed, don't bother
24048 w
->current_matrix
!= NULL
24049 /* Don't update mouse highlight if hidden */
24050 && (draw
!= DRAW_MOUSE_FACE
|| !hlinfo
->mouse_face_hidden
)
24051 /* Recognize when we are called to operate on rows that don't exist
24052 anymore. This can happen when a window is split. */
24053 && hlinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
24055 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
24056 struct glyph_row
*row
, *first
, *last
;
24058 first
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
24059 last
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
24061 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
24063 int start_hpos
, end_hpos
, start_x
;
24065 /* For all but the first row, the highlight starts at column 0. */
24068 /* R2L rows have BEG and END in reversed order, but the
24069 screen drawing geometry is always left to right. So
24070 we need to mirror the beginning and end of the
24071 highlighted area in R2L rows. */
24072 if (!row
->reversed_p
)
24074 start_hpos
= hlinfo
->mouse_face_beg_col
;
24075 start_x
= hlinfo
->mouse_face_beg_x
;
24077 else if (row
== last
)
24079 start_hpos
= hlinfo
->mouse_face_end_col
;
24080 start_x
= hlinfo
->mouse_face_end_x
;
24088 else if (row
->reversed_p
&& row
== last
)
24090 start_hpos
= hlinfo
->mouse_face_end_col
;
24091 start_x
= hlinfo
->mouse_face_end_x
;
24101 if (!row
->reversed_p
)
24102 end_hpos
= hlinfo
->mouse_face_end_col
;
24103 else if (row
== first
)
24104 end_hpos
= hlinfo
->mouse_face_beg_col
;
24107 end_hpos
= row
->used
[TEXT_AREA
];
24108 if (draw
== DRAW_NORMAL_TEXT
)
24109 row
->fill_line_p
= 1; /* Clear to end of line */
24112 else if (row
->reversed_p
&& row
== first
)
24113 end_hpos
= hlinfo
->mouse_face_beg_col
;
24116 end_hpos
= row
->used
[TEXT_AREA
];
24117 if (draw
== DRAW_NORMAL_TEXT
)
24118 row
->fill_line_p
= 1; /* Clear to end of line */
24121 if (end_hpos
> start_hpos
)
24123 draw_row_with_mouse_face (w
, start_x
, row
,
24124 start_hpos
, end_hpos
, draw
);
24127 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
24131 #ifdef HAVE_WINDOW_SYSTEM
24132 /* When we've written over the cursor, arrange for it to
24133 be displayed again. */
24134 if (FRAME_WINDOW_P (f
)
24135 && phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
24138 display_and_set_cursor (w
, 1,
24139 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
24140 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
24143 #endif /* HAVE_WINDOW_SYSTEM */
24146 #ifdef HAVE_WINDOW_SYSTEM
24147 /* Change the mouse cursor. */
24148 if (FRAME_WINDOW_P (f
))
24150 if (draw
== DRAW_NORMAL_TEXT
24151 && !EQ (hlinfo
->mouse_face_window
, f
->tool_bar_window
))
24152 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
24153 else if (draw
== DRAW_MOUSE_FACE
)
24154 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
24156 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
24158 #endif /* HAVE_WINDOW_SYSTEM */
24162 Clear out the mouse-highlighted active region.
24163 Redraw it un-highlighted first. Value is non-zero if mouse
24164 face was actually drawn unhighlighted. */
24167 clear_mouse_face (Mouse_HLInfo
*hlinfo
)
24171 if (!hlinfo
->mouse_face_hidden
&& !NILP (hlinfo
->mouse_face_window
))
24173 show_mouse_face (hlinfo
, DRAW_NORMAL_TEXT
);
24177 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
24178 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
24179 hlinfo
->mouse_face_window
= Qnil
;
24180 hlinfo
->mouse_face_overlay
= Qnil
;
24184 /* Return non-zero if the coordinates HPOS and VPOS on windows W are
24185 within the mouse face on that window. */
24187 coords_in_mouse_face_p (struct window
*w
, int hpos
, int vpos
)
24189 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
24191 /* Quickly resolve the easy cases. */
24192 if (!(WINDOWP (hlinfo
->mouse_face_window
)
24193 && XWINDOW (hlinfo
->mouse_face_window
) == w
))
24195 if (vpos
< hlinfo
->mouse_face_beg_row
24196 || vpos
> hlinfo
->mouse_face_end_row
)
24198 if (vpos
> hlinfo
->mouse_face_beg_row
24199 && vpos
< hlinfo
->mouse_face_end_row
)
24202 if (!MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
)
24204 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
24206 if (hlinfo
->mouse_face_beg_col
<= hpos
&& hpos
< hlinfo
->mouse_face_end_col
)
24209 else if ((vpos
== hlinfo
->mouse_face_beg_row
24210 && hpos
>= hlinfo
->mouse_face_beg_col
)
24211 || (vpos
== hlinfo
->mouse_face_end_row
24212 && hpos
< hlinfo
->mouse_face_end_col
))
24217 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
24219 if (hlinfo
->mouse_face_end_col
< hpos
&& hpos
<= hlinfo
->mouse_face_beg_col
)
24222 else if ((vpos
== hlinfo
->mouse_face_beg_row
24223 && hpos
<= hlinfo
->mouse_face_beg_col
)
24224 || (vpos
== hlinfo
->mouse_face_end_row
24225 && hpos
> hlinfo
->mouse_face_end_col
))
24233 Non-zero if physical cursor of window W is within mouse face. */
24236 cursor_in_mouse_face_p (struct window
*w
)
24238 return coords_in_mouse_face_p (w
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
);
24243 /* Find the glyph rows START_ROW and END_ROW of window W that display
24244 characters between buffer positions START_CHARPOS and END_CHARPOS
24245 (excluding END_CHARPOS). This is similar to row_containing_pos,
24246 but is more accurate when bidi reordering makes buffer positions
24247 change non-linearly with glyph rows. */
24249 rows_from_pos_range (struct window
*w
,
24250 EMACS_INT start_charpos
, EMACS_INT end_charpos
,
24251 struct glyph_row
**start
, struct glyph_row
**end
)
24253 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
24254 int last_y
= window_text_bottom_y (w
);
24255 struct glyph_row
*row
;
24260 while (!first
->enabled_p
24261 && first
< MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
24264 /* Find the START row. */
24266 row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
;
24269 /* A row can potentially be the START row if the range of the
24270 characters it displays intersects the range
24271 [START_CHARPOS..END_CHARPOS). */
24272 if (! ((start_charpos
< MATRIX_ROW_START_CHARPOS (row
)
24273 && end_charpos
< MATRIX_ROW_START_CHARPOS (row
))
24274 /* See the commentary in row_containing_pos, for the
24275 explanation of the complicated way to check whether
24276 some position is beyond the end of the characters
24277 displayed by a row. */
24278 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (row
)
24279 || (start_charpos
== MATRIX_ROW_END_CHARPOS (row
)
24280 && !row
->ends_at_zv_p
24281 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
24282 && (end_charpos
> MATRIX_ROW_END_CHARPOS (row
)
24283 || (end_charpos
== MATRIX_ROW_END_CHARPOS (row
)
24284 && !row
->ends_at_zv_p
24285 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))))
24287 /* Found a candidate row. Now make sure at least one of the
24288 glyphs it displays has a charpos from the range
24289 [START_CHARPOS..END_CHARPOS).
24291 This is not obvious because bidi reordering could make
24292 buffer positions of a row be 1,2,3,102,101,100, and if we
24293 want to highlight characters in [50..60), we don't want
24294 this row, even though [50..60) does intersect [1..103),
24295 the range of character positions given by the row's start
24296 and end positions. */
24297 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
24298 struct glyph
*e
= g
+ row
->used
[TEXT_AREA
];
24302 if (BUFFERP (g
->object
)
24303 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
24312 /* Find the END row. */
24314 /* If the last row is partially visible, start looking for END
24315 from that row, instead of starting from FIRST. */
24316 && !(row
->enabled_p
24317 && row
->y
< last_y
&& MATRIX_ROW_BOTTOM_Y (row
) > last_y
))
24319 for ( ; row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
; row
++)
24321 struct glyph_row
*next
= row
+ 1;
24323 if (!next
->enabled_p
24324 || next
>= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
)
24325 /* The first row >= START whose range of displayed characters
24326 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
24327 is the row END + 1. */
24328 || (start_charpos
< MATRIX_ROW_START_CHARPOS (next
)
24329 && end_charpos
< MATRIX_ROW_START_CHARPOS (next
))
24330 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (next
)
24331 || (start_charpos
== MATRIX_ROW_END_CHARPOS (next
)
24332 && !next
->ends_at_zv_p
24333 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))
24334 && (end_charpos
> MATRIX_ROW_END_CHARPOS (next
)
24335 || (end_charpos
== MATRIX_ROW_END_CHARPOS (next
)
24336 && !next
->ends_at_zv_p
24337 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))))
24344 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
24345 but none of the characters it displays are in the range, it is
24347 struct glyph
*g
= next
->glyphs
[TEXT_AREA
];
24348 struct glyph
*e
= g
+ next
->used
[TEXT_AREA
];
24352 if (BUFFERP (g
->object
)
24353 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
24366 /* This function sets the mouse_face_* elements of HLINFO, assuming
24367 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
24368 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
24369 for the overlay or run of text properties specifying the mouse
24370 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
24371 before-string and after-string that must also be highlighted.
24372 COVER_STRING, if non-nil, is a display string that may cover some
24373 or all of the highlighted text. */
24376 mouse_face_from_buffer_pos (Lisp_Object window
,
24377 Mouse_HLInfo
*hlinfo
,
24378 EMACS_INT mouse_charpos
,
24379 EMACS_INT start_charpos
,
24380 EMACS_INT end_charpos
,
24381 Lisp_Object before_string
,
24382 Lisp_Object after_string
,
24383 Lisp_Object cover_string
)
24385 struct window
*w
= XWINDOW (window
);
24386 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
24387 struct glyph_row
*r1
, *r2
;
24388 struct glyph
*glyph
, *end
;
24389 EMACS_INT ignore
, pos
;
24392 xassert (NILP (cover_string
) || STRINGP (cover_string
));
24393 xassert (NILP (before_string
) || STRINGP (before_string
));
24394 xassert (NILP (after_string
) || STRINGP (after_string
));
24396 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
24397 rows_from_pos_range (w
, start_charpos
, end_charpos
, &r1
, &r2
);
24399 r1
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
24400 /* If the before-string or display-string contains newlines,
24401 rows_from_pos_range skips to its last row. Move back. */
24402 if (!NILP (before_string
) || !NILP (cover_string
))
24404 struct glyph_row
*prev
;
24405 while ((prev
= r1
- 1, prev
>= first
)
24406 && MATRIX_ROW_END_CHARPOS (prev
) == start_charpos
24407 && prev
->used
[TEXT_AREA
] > 0)
24409 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
24410 glyph
= beg
+ prev
->used
[TEXT_AREA
];
24411 while (--glyph
>= beg
&& INTEGERP (glyph
->object
));
24413 || !(EQ (glyph
->object
, before_string
)
24414 || EQ (glyph
->object
, cover_string
)))
24421 r2
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
24422 hlinfo
->mouse_face_past_end
= 1;
24424 else if (!NILP (after_string
))
24426 /* If the after-string has newlines, advance to its last row. */
24427 struct glyph_row
*next
;
24428 struct glyph_row
*last
24429 = MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
24431 for (next
= r2
+ 1;
24433 && next
->used
[TEXT_AREA
] > 0
24434 && EQ (next
->glyphs
[TEXT_AREA
]->object
, after_string
);
24438 /* The rest of the display engine assumes that mouse_face_beg_row is
24439 either above below mouse_face_end_row or identical to it. But
24440 with bidi-reordered continued lines, the row for START_CHARPOS
24441 could be below the row for END_CHARPOS. If so, swap the rows and
24442 store them in correct order. */
24445 struct glyph_row
*tem
= r2
;
24451 hlinfo
->mouse_face_beg_y
= r1
->y
;
24452 hlinfo
->mouse_face_beg_row
= MATRIX_ROW_VPOS (r1
, w
->current_matrix
);
24453 hlinfo
->mouse_face_end_y
= r2
->y
;
24454 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r2
, w
->current_matrix
);
24456 /* For a bidi-reordered row, the positions of BEFORE_STRING,
24457 AFTER_STRING, COVER_STRING, START_CHARPOS, and END_CHARPOS
24458 could be anywhere in the row and in any order. The strategy
24459 below is to find the leftmost and the rightmost glyph that
24460 belongs to either of these 3 strings, or whose position is
24461 between START_CHARPOS and END_CHARPOS, and highlight all the
24462 glyphs between those two. This may cover more than just the text
24463 between START_CHARPOS and END_CHARPOS if the range of characters
24464 strides the bidi level boundary, e.g. if the beginning is in R2L
24465 text while the end is in L2R text or vice versa. */
24466 if (!r1
->reversed_p
)
24468 /* This row is in a left to right paragraph. Scan it left to
24470 glyph
= r1
->glyphs
[TEXT_AREA
];
24471 end
= glyph
+ r1
->used
[TEXT_AREA
];
24474 /* Skip truncation glyphs at the start of the glyph row. */
24475 if (r1
->displays_text_p
)
24477 && INTEGERP (glyph
->object
)
24478 && glyph
->charpos
< 0;
24480 x
+= glyph
->pixel_width
;
24482 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
24483 or COVER_STRING, and the first glyph from buffer whose
24484 position is between START_CHARPOS and END_CHARPOS. */
24486 && !INTEGERP (glyph
->object
)
24487 && !EQ (glyph
->object
, cover_string
)
24488 && !(BUFFERP (glyph
->object
)
24489 && (glyph
->charpos
>= start_charpos
24490 && glyph
->charpos
< end_charpos
));
24493 /* BEFORE_STRING or AFTER_STRING are only relevant if they
24494 are present at buffer positions between START_CHARPOS and
24495 END_CHARPOS, or if they come from an overlay. */
24496 if (EQ (glyph
->object
, before_string
))
24498 pos
= string_buffer_position (before_string
,
24500 /* If pos == 0, it means before_string came from an
24501 overlay, not from a buffer position. */
24502 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24505 else if (EQ (glyph
->object
, after_string
))
24507 pos
= string_buffer_position (after_string
, end_charpos
);
24508 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24511 x
+= glyph
->pixel_width
;
24513 hlinfo
->mouse_face_beg_x
= x
;
24514 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
24518 /* This row is in a right to left paragraph. Scan it right to
24522 end
= r1
->glyphs
[TEXT_AREA
] - 1;
24523 glyph
= end
+ r1
->used
[TEXT_AREA
];
24525 /* Skip truncation glyphs at the start of the glyph row. */
24526 if (r1
->displays_text_p
)
24528 && INTEGERP (glyph
->object
)
24529 && glyph
->charpos
< 0;
24533 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
24534 or COVER_STRING, and the first glyph from buffer whose
24535 position is between START_CHARPOS and END_CHARPOS. */
24537 && !INTEGERP (glyph
->object
)
24538 && !EQ (glyph
->object
, cover_string
)
24539 && !(BUFFERP (glyph
->object
)
24540 && (glyph
->charpos
>= start_charpos
24541 && glyph
->charpos
< end_charpos
));
24544 /* BEFORE_STRING or AFTER_STRING are only relevant if they
24545 are present at buffer positions between START_CHARPOS and
24546 END_CHARPOS, or if they come from an overlay. */
24547 if (EQ (glyph
->object
, before_string
))
24549 pos
= string_buffer_position (before_string
, start_charpos
);
24550 /* If pos == 0, it means before_string came from an
24551 overlay, not from a buffer position. */
24552 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24555 else if (EQ (glyph
->object
, after_string
))
24557 pos
= string_buffer_position (after_string
, end_charpos
);
24558 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24563 glyph
++; /* first glyph to the right of the highlighted area */
24564 for (g
= r1
->glyphs
[TEXT_AREA
], x
= r1
->x
; g
< glyph
; g
++)
24565 x
+= g
->pixel_width
;
24566 hlinfo
->mouse_face_beg_x
= x
;
24567 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
24570 /* If the highlight ends in a different row, compute GLYPH and END
24571 for the end row. Otherwise, reuse the values computed above for
24572 the row where the highlight begins. */
24575 if (!r2
->reversed_p
)
24577 glyph
= r2
->glyphs
[TEXT_AREA
];
24578 end
= glyph
+ r2
->used
[TEXT_AREA
];
24583 end
= r2
->glyphs
[TEXT_AREA
] - 1;
24584 glyph
= end
+ r2
->used
[TEXT_AREA
];
24588 if (!r2
->reversed_p
)
24590 /* Skip truncation and continuation glyphs near the end of the
24591 row, and also blanks and stretch glyphs inserted by
24592 extend_face_to_end_of_line. */
24594 && INTEGERP ((end
- 1)->object
)
24595 && (end
- 1)->charpos
<= 0)
24597 /* Scan the rest of the glyph row from the end, looking for the
24598 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
24599 COVER_STRING, or whose position is between START_CHARPOS
24603 && !INTEGERP (end
->object
)
24604 && !EQ (end
->object
, cover_string
)
24605 && !(BUFFERP (end
->object
)
24606 && (end
->charpos
>= start_charpos
24607 && end
->charpos
< end_charpos
));
24610 /* BEFORE_STRING or AFTER_STRING are only relevant if they
24611 are present at buffer positions between START_CHARPOS and
24612 END_CHARPOS, or if they come from an overlay. */
24613 if (EQ (end
->object
, before_string
))
24615 pos
= string_buffer_position (before_string
, start_charpos
);
24616 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24619 else if (EQ (end
->object
, after_string
))
24621 pos
= string_buffer_position (after_string
, end_charpos
);
24622 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24626 /* Find the X coordinate of the last glyph to be highlighted. */
24627 for (; glyph
<= end
; ++glyph
)
24628 x
+= glyph
->pixel_width
;
24630 hlinfo
->mouse_face_end_x
= x
;
24631 hlinfo
->mouse_face_end_col
= glyph
- r2
->glyphs
[TEXT_AREA
];
24635 /* Skip truncation and continuation glyphs near the end of the
24636 row, and also blanks and stretch glyphs inserted by
24637 extend_face_to_end_of_line. */
24641 && INTEGERP (end
->object
)
24642 && end
->charpos
<= 0)
24644 x
+= end
->pixel_width
;
24647 /* Scan the rest of the glyph row from the end, looking for the
24648 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
24649 COVER_STRING, or whose position is between START_CHARPOS
24653 && !INTEGERP (end
->object
)
24654 && !EQ (end
->object
, cover_string
)
24655 && !(BUFFERP (end
->object
)
24656 && (end
->charpos
>= start_charpos
24657 && end
->charpos
< end_charpos
));
24660 /* BEFORE_STRING or AFTER_STRING are only relevant if they
24661 are present at buffer positions between START_CHARPOS and
24662 END_CHARPOS, or if they come from an overlay. */
24663 if (EQ (end
->object
, before_string
))
24665 pos
= string_buffer_position (before_string
, start_charpos
);
24666 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24669 else if (EQ (end
->object
, after_string
))
24671 pos
= string_buffer_position (after_string
, end_charpos
);
24672 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
24675 x
+= end
->pixel_width
;
24677 hlinfo
->mouse_face_end_x
= x
;
24678 hlinfo
->mouse_face_end_col
= end
- r2
->glyphs
[TEXT_AREA
];
24681 hlinfo
->mouse_face_window
= window
;
24682 hlinfo
->mouse_face_face_id
24683 = face_at_buffer_position (w
, mouse_charpos
, 0, 0, &ignore
,
24685 !hlinfo
->mouse_face_hidden
, -1);
24686 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
24689 /* The following function is not used anymore (replaced with
24690 mouse_face_from_string_pos), but I leave it here for the time
24691 being, in case someone would. */
24693 #if 0 /* not used */
24695 /* Find the position of the glyph for position POS in OBJECT in
24696 window W's current matrix, and return in *X, *Y the pixel
24697 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
24699 RIGHT_P non-zero means return the position of the right edge of the
24700 glyph, RIGHT_P zero means return the left edge position.
24702 If no glyph for POS exists in the matrix, return the position of
24703 the glyph with the next smaller position that is in the matrix, if
24704 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
24705 exists in the matrix, return the position of the glyph with the
24706 next larger position in OBJECT.
24708 Value is non-zero if a glyph was found. */
24711 fast_find_string_pos (struct window
*w
, EMACS_INT pos
, Lisp_Object object
,
24712 int *hpos
, int *vpos
, int *x
, int *y
, int right_p
)
24714 int yb
= window_text_bottom_y (w
);
24715 struct glyph_row
*r
;
24716 struct glyph
*best_glyph
= NULL
;
24717 struct glyph_row
*best_row
= NULL
;
24720 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
24721 r
->enabled_p
&& r
->y
< yb
;
24724 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
24725 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
24728 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
24729 if (EQ (g
->object
, object
))
24731 if (g
->charpos
== pos
)
24738 else if (best_glyph
== NULL
24739 || ((eabs (g
->charpos
- pos
)
24740 < eabs (best_glyph
->charpos
- pos
))
24743 : g
->charpos
> pos
)))
24757 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
24761 *x
+= best_glyph
->pixel_width
;
24766 *vpos
= best_row
- w
->current_matrix
->rows
;
24769 return best_glyph
!= NULL
;
24771 #endif /* not used */
24773 /* Find the positions of the first and the last glyphs in window W's
24774 current matrix that occlude positions [STARTPOS..ENDPOS] in OBJECT
24775 (assumed to be a string), and return in HLINFO's mouse_face_*
24776 members the pixel and column/row coordinates of those glyphs. */
24779 mouse_face_from_string_pos (struct window
*w
, Mouse_HLInfo
*hlinfo
,
24780 Lisp_Object object
,
24781 EMACS_INT startpos
, EMACS_INT endpos
)
24783 int yb
= window_text_bottom_y (w
);
24784 struct glyph_row
*r
;
24785 struct glyph
*g
, *e
;
24789 /* Find the glyph row with at least one position in the range
24790 [STARTPOS..ENDPOS], and the first glyph in that row whose
24791 position belongs to that range. */
24792 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
24793 r
->enabled_p
&& r
->y
< yb
;
24796 if (!r
->reversed_p
)
24798 g
= r
->glyphs
[TEXT_AREA
];
24799 e
= g
+ r
->used
[TEXT_AREA
];
24800 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
24801 if (EQ (g
->object
, object
)
24802 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
24804 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
24805 hlinfo
->mouse_face_beg_y
= r
->y
;
24806 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
24807 hlinfo
->mouse_face_beg_x
= gx
;
24816 e
= r
->glyphs
[TEXT_AREA
];
24817 g
= e
+ r
->used
[TEXT_AREA
];
24818 for ( ; g
> e
; --g
)
24819 if (EQ ((g
-1)->object
, object
)
24820 && startpos
<= (g
-1)->charpos
&& (g
-1)->charpos
<= endpos
)
24822 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
24823 hlinfo
->mouse_face_beg_y
= r
->y
;
24824 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
24825 for (gx
= r
->x
, g1
= r
->glyphs
[TEXT_AREA
]; g1
< g
; ++g1
)
24826 gx
+= g1
->pixel_width
;
24827 hlinfo
->mouse_face_beg_x
= gx
;
24839 /* Starting with the next row, look for the first row which does NOT
24840 include any glyphs whose positions are in the range. */
24841 for (++r
; r
->enabled_p
&& r
->y
< yb
; ++r
)
24843 g
= r
->glyphs
[TEXT_AREA
];
24844 e
= g
+ r
->used
[TEXT_AREA
];
24846 for ( ; g
< e
; ++g
)
24847 if (EQ (g
->object
, object
)
24848 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
24857 /* The highlighted region ends on the previous row. */
24860 /* Set the end row and its vertical pixel coordinate. */
24861 hlinfo
->mouse_face_end_row
= r
- w
->current_matrix
->rows
;
24862 hlinfo
->mouse_face_end_y
= r
->y
;
24864 /* Compute and set the end column and the end column's horizontal
24865 pixel coordinate. */
24866 if (!r
->reversed_p
)
24868 g
= r
->glyphs
[TEXT_AREA
];
24869 e
= g
+ r
->used
[TEXT_AREA
];
24870 for ( ; e
> g
; --e
)
24871 if (EQ ((e
-1)->object
, object
)
24872 && startpos
<= (e
-1)->charpos
&& (e
-1)->charpos
<= endpos
)
24874 hlinfo
->mouse_face_end_col
= e
- g
;
24876 for (gx
= r
->x
; g
< e
; ++g
)
24877 gx
+= g
->pixel_width
;
24878 hlinfo
->mouse_face_end_x
= gx
;
24882 e
= r
->glyphs
[TEXT_AREA
];
24883 g
= e
+ r
->used
[TEXT_AREA
];
24884 for (gx
= r
->x
; e
< g
; ++e
)
24886 if (EQ (e
->object
, object
)
24887 && startpos
<= e
->charpos
&& e
->charpos
<= endpos
)
24889 gx
+= e
->pixel_width
;
24891 hlinfo
->mouse_face_end_col
= e
- r
->glyphs
[TEXT_AREA
];
24892 hlinfo
->mouse_face_end_x
= gx
;
24896 #ifdef HAVE_WINDOW_SYSTEM
24898 /* See if position X, Y is within a hot-spot of an image. */
24901 on_hot_spot_p (Lisp_Object hot_spot
, int x
, int y
)
24903 if (!CONSP (hot_spot
))
24906 if (EQ (XCAR (hot_spot
), Qrect
))
24908 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
24909 Lisp_Object rect
= XCDR (hot_spot
);
24913 if (!CONSP (XCAR (rect
)))
24915 if (!CONSP (XCDR (rect
)))
24917 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
24919 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
24921 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
24923 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
24927 else if (EQ (XCAR (hot_spot
), Qcircle
))
24929 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
24930 Lisp_Object circ
= XCDR (hot_spot
);
24931 Lisp_Object lr
, lx0
, ly0
;
24933 && CONSP (XCAR (circ
))
24934 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
24935 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
24936 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
24938 double r
= XFLOATINT (lr
);
24939 double dx
= XINT (lx0
) - x
;
24940 double dy
= XINT (ly0
) - y
;
24941 return (dx
* dx
+ dy
* dy
<= r
* r
);
24944 else if (EQ (XCAR (hot_spot
), Qpoly
))
24946 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
24947 if (VECTORP (XCDR (hot_spot
)))
24949 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
24950 Lisp_Object
*poly
= v
->contents
;
24951 int n
= v
->header
.size
;
24954 Lisp_Object lx
, ly
;
24957 /* Need an even number of coordinates, and at least 3 edges. */
24958 if (n
< 6 || n
& 1)
24961 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
24962 If count is odd, we are inside polygon. Pixels on edges
24963 may or may not be included depending on actual geometry of the
24965 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
24966 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
24968 x0
= XINT (lx
), y0
= XINT (ly
);
24969 for (i
= 0; i
< n
; i
+= 2)
24971 int x1
= x0
, y1
= y0
;
24972 if ((lx
= poly
[i
], !INTEGERP (lx
))
24973 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
24975 x0
= XINT (lx
), y0
= XINT (ly
);
24977 /* Does this segment cross the X line? */
24985 if (y
> y0
&& y
> y1
)
24987 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
24997 find_hot_spot (Lisp_Object map
, int x
, int y
)
24999 while (CONSP (map
))
25001 if (CONSP (XCAR (map
))
25002 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
25010 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
25012 doc
: /* Lookup in image map MAP coordinates X and Y.
25013 An image map is an alist where each element has the format (AREA ID PLIST).
25014 An AREA is specified as either a rectangle, a circle, or a polygon:
25015 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
25016 pixel coordinates of the upper left and bottom right corners.
25017 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
25018 and the radius of the circle; r may be a float or integer.
25019 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
25020 vector describes one corner in the polygon.
25021 Returns the alist element for the first matching AREA in MAP. */)
25022 (Lisp_Object map
, Lisp_Object x
, Lisp_Object y
)
25030 return find_hot_spot (map
, XINT (x
), XINT (y
));
25034 /* Display frame CURSOR, optionally using shape defined by POINTER. */
25036 define_frame_cursor1 (struct frame
*f
, Cursor cursor
, Lisp_Object pointer
)
25038 /* Do not change cursor shape while dragging mouse. */
25039 if (!NILP (do_mouse_tracking
))
25042 if (!NILP (pointer
))
25044 if (EQ (pointer
, Qarrow
))
25045 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25046 else if (EQ (pointer
, Qhand
))
25047 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
25048 else if (EQ (pointer
, Qtext
))
25049 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
25050 else if (EQ (pointer
, intern ("hdrag")))
25051 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
25052 #ifdef HAVE_X_WINDOWS
25053 else if (EQ (pointer
, intern ("vdrag")))
25054 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
25056 else if (EQ (pointer
, intern ("hourglass")))
25057 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
25058 else if (EQ (pointer
, Qmodeline
))
25059 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
25061 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25064 if (cursor
!= No_Cursor
)
25065 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
25068 #endif /* HAVE_WINDOW_SYSTEM */
25070 /* Take proper action when mouse has moved to the mode or header line
25071 or marginal area AREA of window W, x-position X and y-position Y.
25072 X is relative to the start of the text display area of W, so the
25073 width of bitmap areas and scroll bars must be subtracted to get a
25074 position relative to the start of the mode line. */
25077 note_mode_line_or_margin_highlight (Lisp_Object window
, int x
, int y
,
25078 enum window_part area
)
25080 struct window
*w
= XWINDOW (window
);
25081 struct frame
*f
= XFRAME (w
->frame
);
25082 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25083 #ifdef HAVE_WINDOW_SYSTEM
25084 Display_Info
*dpyinfo
;
25086 Cursor cursor
= No_Cursor
;
25087 Lisp_Object pointer
= Qnil
;
25088 int dx
, dy
, width
, height
;
25090 Lisp_Object string
, object
= Qnil
;
25091 Lisp_Object pos
, help
;
25093 Lisp_Object mouse_face
;
25094 int original_x_pixel
= x
;
25095 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
25096 struct glyph_row
*row
;
25098 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
25103 /* Kludge alert: mode_line_string takes X/Y in pixels, but
25104 returns them in row/column units! */
25105 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
25106 &object
, &dx
, &dy
, &width
, &height
);
25108 row
= (area
== ON_MODE_LINE
25109 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
25110 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
25112 /* Find the glyph under the mouse pointer. */
25113 if (row
->mode_line_p
&& row
->enabled_p
)
25115 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
25116 end
= glyph
+ row
->used
[TEXT_AREA
];
25118 for (x0
= original_x_pixel
;
25119 glyph
< end
&& x0
>= glyph
->pixel_width
;
25121 x0
-= glyph
->pixel_width
;
25129 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
25130 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
25131 returns them in row/column units! */
25132 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
25133 &object
, &dx
, &dy
, &width
, &height
);
25138 #ifdef HAVE_WINDOW_SYSTEM
25139 if (IMAGEP (object
))
25141 Lisp_Object image_map
, hotspot
;
25142 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
25144 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
25146 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
25150 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
25151 If so, we could look for mouse-enter, mouse-leave
25152 properties in PLIST (and do something...). */
25153 hotspot
= XCDR (hotspot
);
25154 if (CONSP (hotspot
)
25155 && (plist
= XCAR (hotspot
), CONSP (plist
)))
25157 pointer
= Fplist_get (plist
, Qpointer
);
25158 if (NILP (pointer
))
25160 help
= Fplist_get (plist
, Qhelp_echo
);
25163 help_echo_string
= help
;
25164 /* Is this correct? ++kfs */
25165 XSETWINDOW (help_echo_window
, w
);
25166 help_echo_object
= w
->buffer
;
25167 help_echo_pos
= charpos
;
25171 if (NILP (pointer
))
25172 pointer
= Fplist_get (XCDR (object
), QCpointer
);
25174 #endif /* HAVE_WINDOW_SYSTEM */
25176 if (STRINGP (string
))
25178 pos
= make_number (charpos
);
25179 /* If we're on a string with `help-echo' text property, arrange
25180 for the help to be displayed. This is done by setting the
25181 global variable help_echo_string to the help string. */
25184 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
25187 help_echo_string
= help
;
25188 XSETWINDOW (help_echo_window
, w
);
25189 help_echo_object
= string
;
25190 help_echo_pos
= charpos
;
25194 #ifdef HAVE_WINDOW_SYSTEM
25195 if (FRAME_WINDOW_P (f
))
25197 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
25198 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25199 if (NILP (pointer
))
25200 pointer
= Fget_text_property (pos
, Qpointer
, string
);
25202 /* Change the mouse pointer according to what is under X/Y. */
25204 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
25207 map
= Fget_text_property (pos
, Qlocal_map
, string
);
25208 if (!KEYMAPP (map
))
25209 map
= Fget_text_property (pos
, Qkeymap
, string
);
25210 if (!KEYMAPP (map
))
25211 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
25216 /* Change the mouse face according to what is under X/Y. */
25217 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
25218 if (!NILP (mouse_face
)
25219 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
25224 struct glyph
* tmp_glyph
;
25228 int total_pixel_width
;
25229 EMACS_INT begpos
, endpos
, ignore
;
25233 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
25234 Qmouse_face
, string
, Qnil
);
25240 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
25242 endpos
= SCHARS (string
);
25246 /* Calculate the glyph position GPOS of GLYPH in the
25247 displayed string, relative to the beginning of the
25248 highlighted part of the string.
25250 Note: GPOS is different from CHARPOS. CHARPOS is the
25251 position of GLYPH in the internal string object. A mode
25252 line string format has structures which are converted to
25253 a flattened string by the Emacs Lisp interpreter. The
25254 internal string is an element of those structures. The
25255 displayed string is the flattened string. */
25256 tmp_glyph
= row_start_glyph
;
25257 while (tmp_glyph
< glyph
25258 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
25259 && begpos
<= tmp_glyph
->charpos
25260 && tmp_glyph
->charpos
< endpos
)))
25262 gpos
= glyph
- tmp_glyph
;
25264 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
25265 the highlighted part of the displayed string to which
25266 GLYPH belongs. Note: GSEQ_LENGTH is different from
25267 SCHARS (STRING), because the latter returns the length of
25268 the internal string. */
25269 for (tmp_glyph
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
25271 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
25272 && begpos
<= tmp_glyph
->charpos
25273 && tmp_glyph
->charpos
< endpos
));
25276 gseq_length
= gpos
+ (tmp_glyph
- glyph
) + 1;
25278 /* Calculate the total pixel width of all the glyphs between
25279 the beginning of the highlighted area and GLYPH. */
25280 total_pixel_width
= 0;
25281 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
25282 total_pixel_width
+= tmp_glyph
->pixel_width
;
25284 /* Pre calculation of re-rendering position. Note: X is in
25285 column units here, after the call to mode_line_string or
25286 marginal_area_string. */
25288 vpos
= (area
== ON_MODE_LINE
25289 ? (w
->current_matrix
)->nrows
- 1
25292 /* If GLYPH's position is included in the region that is
25293 already drawn in mouse face, we have nothing to do. */
25294 if ( EQ (window
, hlinfo
->mouse_face_window
)
25295 && (!row
->reversed_p
25296 ? (hlinfo
->mouse_face_beg_col
<= hpos
25297 && hpos
< hlinfo
->mouse_face_end_col
)
25298 /* In R2L rows we swap BEG and END, see below. */
25299 : (hlinfo
->mouse_face_end_col
<= hpos
25300 && hpos
< hlinfo
->mouse_face_beg_col
))
25301 && hlinfo
->mouse_face_beg_row
== vpos
)
25304 if (clear_mouse_face (hlinfo
))
25305 cursor
= No_Cursor
;
25307 if (!row
->reversed_p
)
25309 hlinfo
->mouse_face_beg_col
= hpos
;
25310 hlinfo
->mouse_face_beg_x
= original_x_pixel
25311 - (total_pixel_width
+ dx
);
25312 hlinfo
->mouse_face_end_col
= hpos
+ gseq_length
;
25313 hlinfo
->mouse_face_end_x
= 0;
25317 /* In R2L rows, show_mouse_face expects BEG and END
25318 coordinates to be swapped. */
25319 hlinfo
->mouse_face_end_col
= hpos
;
25320 hlinfo
->mouse_face_end_x
= original_x_pixel
25321 - (total_pixel_width
+ dx
);
25322 hlinfo
->mouse_face_beg_col
= hpos
+ gseq_length
;
25323 hlinfo
->mouse_face_beg_x
= 0;
25326 hlinfo
->mouse_face_beg_row
= vpos
;
25327 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_beg_row
;
25328 hlinfo
->mouse_face_beg_y
= 0;
25329 hlinfo
->mouse_face_end_y
= 0;
25330 hlinfo
->mouse_face_past_end
= 0;
25331 hlinfo
->mouse_face_window
= window
;
25333 hlinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
25339 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
25341 if (NILP (pointer
))
25344 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
25345 clear_mouse_face (hlinfo
);
25347 #ifdef HAVE_WINDOW_SYSTEM
25348 if (FRAME_WINDOW_P (f
))
25349 define_frame_cursor1 (f
, cursor
, pointer
);
25355 Take proper action when the mouse has moved to position X, Y on
25356 frame F as regards highlighting characters that have mouse-face
25357 properties. Also de-highlighting chars where the mouse was before.
25358 X and Y can be negative or out of range. */
25361 note_mouse_highlight (struct frame
*f
, int x
, int y
)
25363 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25364 enum window_part part
;
25365 Lisp_Object window
;
25367 Cursor cursor
= No_Cursor
;
25368 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
25371 /* When a menu is active, don't highlight because this looks odd. */
25372 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
25373 if (popup_activated ())
25377 if (NILP (Vmouse_highlight
)
25378 || !f
->glyphs_initialized_p
25379 || f
->pointer_invisible
)
25382 hlinfo
->mouse_face_mouse_x
= x
;
25383 hlinfo
->mouse_face_mouse_y
= y
;
25384 hlinfo
->mouse_face_mouse_frame
= f
;
25386 if (hlinfo
->mouse_face_defer
)
25389 if (gc_in_progress
)
25391 hlinfo
->mouse_face_deferred_gc
= 1;
25395 /* Which window is that in? */
25396 window
= window_from_coordinates (f
, x
, y
, &part
, 1);
25398 /* If we were displaying active text in another window, clear that.
25399 Also clear if we move out of text area in same window. */
25400 if (! EQ (window
, hlinfo
->mouse_face_window
)
25401 || (part
!= ON_TEXT
&& part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
25402 && !NILP (hlinfo
->mouse_face_window
)))
25403 clear_mouse_face (hlinfo
);
25405 /* Not on a window -> return. */
25406 if (!WINDOWP (window
))
25409 /* Reset help_echo_string. It will get recomputed below. */
25410 help_echo_string
= Qnil
;
25412 /* Convert to window-relative pixel coordinates. */
25413 w
= XWINDOW (window
);
25414 frame_to_window_pixel_xy (w
, &x
, &y
);
25416 #ifdef HAVE_WINDOW_SYSTEM
25417 /* Handle tool-bar window differently since it doesn't display a
25419 if (EQ (window
, f
->tool_bar_window
))
25421 note_tool_bar_highlight (f
, x
, y
);
25426 /* Mouse is on the mode, header line or margin? */
25427 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
25428 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
25430 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
25434 #ifdef HAVE_WINDOW_SYSTEM
25435 if (part
== ON_VERTICAL_BORDER
)
25437 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
25438 help_echo_string
= build_string ("drag-mouse-1: resize");
25440 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
25441 || part
== ON_SCROLL_BAR
)
25442 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25444 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
25447 /* Are we in a window whose display is up to date?
25448 And verify the buffer's text has not changed. */
25449 b
= XBUFFER (w
->buffer
);
25450 if (part
== ON_TEXT
25451 && EQ (w
->window_end_valid
, w
->buffer
)
25452 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
25453 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
25455 int hpos
, vpos
, i
, dx
, dy
, area
;
25457 struct glyph
*glyph
;
25458 Lisp_Object object
;
25459 Lisp_Object mouse_face
= Qnil
, position
;
25460 Lisp_Object
*overlay_vec
= NULL
;
25462 struct buffer
*obuf
;
25463 EMACS_INT obegv
, ozv
;
25466 /* Find the glyph under X/Y. */
25467 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
25469 #ifdef HAVE_WINDOW_SYSTEM
25470 /* Look for :pointer property on image. */
25471 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
25473 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
25474 if (img
!= NULL
&& IMAGEP (img
->spec
))
25476 Lisp_Object image_map
, hotspot
;
25477 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
25479 && (hotspot
= find_hot_spot (image_map
,
25480 glyph
->slice
.img
.x
+ dx
,
25481 glyph
->slice
.img
.y
+ dy
),
25483 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
25487 /* Could check XCAR (hotspot) to see if we enter/leave
25489 If so, we could look for mouse-enter, mouse-leave
25490 properties in PLIST (and do something...). */
25491 hotspot
= XCDR (hotspot
);
25492 if (CONSP (hotspot
)
25493 && (plist
= XCAR (hotspot
), CONSP (plist
)))
25495 pointer
= Fplist_get (plist
, Qpointer
);
25496 if (NILP (pointer
))
25498 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
25499 if (!NILP (help_echo_string
))
25501 help_echo_window
= window
;
25502 help_echo_object
= glyph
->object
;
25503 help_echo_pos
= glyph
->charpos
;
25507 if (NILP (pointer
))
25508 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
25511 #endif /* HAVE_WINDOW_SYSTEM */
25513 /* Clear mouse face if X/Y not over text. */
25515 || area
!= TEXT_AREA
25516 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
25517 /* Glyph's OBJECT is an integer for glyphs inserted by the
25518 display engine for its internal purposes, like truncation
25519 and continuation glyphs and blanks beyond the end of
25520 line's text on text terminals. If we are over such a
25521 glyph, we are not over any text. */
25522 || INTEGERP (glyph
->object
)
25523 /* R2L rows have a stretch glyph at their front, which
25524 stands for no text, whereas L2R rows have no glyphs at
25525 all beyond the end of text. Treat such stretch glyphs
25526 like we do with NULL glyphs in L2R rows. */
25527 || (MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
25528 && glyph
== MATRIX_ROW (w
->current_matrix
, vpos
)->glyphs
[TEXT_AREA
]
25529 && glyph
->type
== STRETCH_GLYPH
25530 && glyph
->avoid_cursor_p
))
25532 if (clear_mouse_face (hlinfo
))
25533 cursor
= No_Cursor
;
25534 #ifdef HAVE_WINDOW_SYSTEM
25535 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
25537 if (area
!= TEXT_AREA
)
25538 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25540 pointer
= Vvoid_text_area_pointer
;
25546 pos
= glyph
->charpos
;
25547 object
= glyph
->object
;
25548 if (!STRINGP (object
) && !BUFFERP (object
))
25551 /* If we get an out-of-range value, return now; avoid an error. */
25552 if (BUFFERP (object
) && pos
> BUF_Z (b
))
25555 /* Make the window's buffer temporarily current for
25556 overlays_at and compute_char_face. */
25557 obuf
= current_buffer
;
25558 current_buffer
= b
;
25564 /* Is this char mouse-active or does it have help-echo? */
25565 position
= make_number (pos
);
25567 if (BUFFERP (object
))
25569 /* Put all the overlays we want in a vector in overlay_vec. */
25570 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
25571 /* Sort overlays into increasing priority order. */
25572 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
25577 same_region
= coords_in_mouse_face_p (w
, hpos
, vpos
);
25580 cursor
= No_Cursor
;
25582 /* Check mouse-face highlighting. */
25584 /* If there exists an overlay with mouse-face overlapping
25585 the one we are currently highlighting, we have to
25586 check if we enter the overlapping overlay, and then
25587 highlight only that. */
25588 || (OVERLAYP (hlinfo
->mouse_face_overlay
)
25589 && mouse_face_overlay_overlaps (hlinfo
->mouse_face_overlay
)))
25591 /* Find the highest priority overlay with a mouse-face. */
25592 Lisp_Object overlay
= Qnil
;
25593 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
25595 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
25596 if (!NILP (mouse_face
))
25597 overlay
= overlay_vec
[i
];
25600 /* If we're highlighting the same overlay as before, there's
25601 no need to do that again. */
25602 if (!NILP (overlay
) && EQ (overlay
, hlinfo
->mouse_face_overlay
))
25603 goto check_help_echo
;
25604 hlinfo
->mouse_face_overlay
= overlay
;
25606 /* Clear the display of the old active region, if any. */
25607 if (clear_mouse_face (hlinfo
))
25608 cursor
= No_Cursor
;
25610 /* If no overlay applies, get a text property. */
25611 if (NILP (overlay
))
25612 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
25614 /* Next, compute the bounds of the mouse highlighting and
25616 if (!NILP (mouse_face
) && STRINGP (object
))
25618 /* The mouse-highlighting comes from a display string
25619 with a mouse-face. */
25623 s
= Fprevious_single_property_change
25624 (make_number (pos
+ 1), Qmouse_face
, object
, Qnil
);
25625 e
= Fnext_single_property_change
25626 (position
, Qmouse_face
, object
, Qnil
);
25628 s
= make_number (0);
25630 e
= make_number (SCHARS (object
) - 1);
25631 mouse_face_from_string_pos (w
, hlinfo
, object
,
25632 XINT (s
), XINT (e
));
25633 hlinfo
->mouse_face_past_end
= 0;
25634 hlinfo
->mouse_face_window
= window
;
25635 hlinfo
->mouse_face_face_id
25636 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
25637 glyph
->face_id
, 1);
25638 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
25639 cursor
= No_Cursor
;
25643 /* The mouse-highlighting, if any, comes from an overlay
25644 or text property in the buffer. */
25645 Lisp_Object buffer
IF_LINT (= Qnil
);
25646 Lisp_Object cover_string
IF_LINT (= Qnil
);
25648 if (STRINGP (object
))
25650 /* If we are on a display string with no mouse-face,
25651 check if the text under it has one. */
25652 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
25653 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
25654 pos
= string_buffer_position (object
, start
);
25657 mouse_face
= get_char_property_and_overlay
25658 (make_number (pos
), Qmouse_face
, w
->buffer
, &overlay
);
25659 buffer
= w
->buffer
;
25660 cover_string
= object
;
25666 cover_string
= Qnil
;
25669 if (!NILP (mouse_face
))
25671 Lisp_Object before
, after
;
25672 Lisp_Object before_string
, after_string
;
25673 /* To correctly find the limits of mouse highlight
25674 in a bidi-reordered buffer, we must not use the
25675 optimization of limiting the search in
25676 previous-single-property-change and
25677 next-single-property-change, because
25678 rows_from_pos_range needs the real start and end
25679 positions to DTRT in this case. That's because
25680 the first row visible in a window does not
25681 necessarily display the character whose position
25682 is the smallest. */
25684 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
25685 ? Fmarker_position (w
->start
)
25688 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
25689 ? make_number (BUF_Z (XBUFFER (buffer
))
25690 - XFASTINT (w
->window_end_pos
))
25693 if (NILP (overlay
))
25695 /* Handle the text property case. */
25696 before
= Fprevious_single_property_change
25697 (make_number (pos
+ 1), Qmouse_face
, buffer
, lim1
);
25698 after
= Fnext_single_property_change
25699 (make_number (pos
), Qmouse_face
, buffer
, lim2
);
25700 before_string
= after_string
= Qnil
;
25704 /* Handle the overlay case. */
25705 before
= Foverlay_start (overlay
);
25706 after
= Foverlay_end (overlay
);
25707 before_string
= Foverlay_get (overlay
, Qbefore_string
);
25708 after_string
= Foverlay_get (overlay
, Qafter_string
);
25710 if (!STRINGP (before_string
)) before_string
= Qnil
;
25711 if (!STRINGP (after_string
)) after_string
= Qnil
;
25714 mouse_face_from_buffer_pos (window
, hlinfo
, pos
,
25717 before_string
, after_string
,
25719 cursor
= No_Cursor
;
25726 /* Look for a `help-echo' property. */
25727 if (NILP (help_echo_string
)) {
25728 Lisp_Object help
, overlay
;
25730 /* Check overlays first. */
25731 help
= overlay
= Qnil
;
25732 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
25734 overlay
= overlay_vec
[i
];
25735 help
= Foverlay_get (overlay
, Qhelp_echo
);
25740 help_echo_string
= help
;
25741 help_echo_window
= window
;
25742 help_echo_object
= overlay
;
25743 help_echo_pos
= pos
;
25747 Lisp_Object obj
= glyph
->object
;
25748 EMACS_INT charpos
= glyph
->charpos
;
25750 /* Try text properties. */
25753 && charpos
< SCHARS (obj
))
25755 help
= Fget_text_property (make_number (charpos
),
25759 /* If the string itself doesn't specify a help-echo,
25760 see if the buffer text ``under'' it does. */
25761 struct glyph_row
*r
25762 = MATRIX_ROW (w
->current_matrix
, vpos
);
25763 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
25764 EMACS_INT p
= string_buffer_position (obj
, start
);
25767 help
= Fget_char_property (make_number (p
),
25768 Qhelp_echo
, w
->buffer
);
25777 else if (BUFFERP (obj
)
25780 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
25785 help_echo_string
= help
;
25786 help_echo_window
= window
;
25787 help_echo_object
= obj
;
25788 help_echo_pos
= charpos
;
25793 #ifdef HAVE_WINDOW_SYSTEM
25794 /* Look for a `pointer' property. */
25795 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
25797 /* Check overlays first. */
25798 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
25799 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
25801 if (NILP (pointer
))
25803 Lisp_Object obj
= glyph
->object
;
25804 EMACS_INT charpos
= glyph
->charpos
;
25806 /* Try text properties. */
25809 && charpos
< SCHARS (obj
))
25811 pointer
= Fget_text_property (make_number (charpos
),
25813 if (NILP (pointer
))
25815 /* If the string itself doesn't specify a pointer,
25816 see if the buffer text ``under'' it does. */
25817 struct glyph_row
*r
25818 = MATRIX_ROW (w
->current_matrix
, vpos
);
25819 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
25820 EMACS_INT p
= string_buffer_position (obj
, start
);
25822 pointer
= Fget_char_property (make_number (p
),
25823 Qpointer
, w
->buffer
);
25826 else if (BUFFERP (obj
)
25829 pointer
= Fget_text_property (make_number (charpos
),
25833 #endif /* HAVE_WINDOW_SYSTEM */
25837 current_buffer
= obuf
;
25842 #ifdef HAVE_WINDOW_SYSTEM
25843 if (FRAME_WINDOW_P (f
))
25844 define_frame_cursor1 (f
, cursor
, pointer
);
25846 /* This is here to prevent a compiler error, about "label at end of
25847 compound statement". */
25854 Clear any mouse-face on window W. This function is part of the
25855 redisplay interface, and is called from try_window_id and similar
25856 functions to ensure the mouse-highlight is off. */
25859 x_clear_window_mouse_face (struct window
*w
)
25861 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
25862 Lisp_Object window
;
25865 XSETWINDOW (window
, w
);
25866 if (EQ (window
, hlinfo
->mouse_face_window
))
25867 clear_mouse_face (hlinfo
);
25873 Just discard the mouse face information for frame F, if any.
25874 This is used when the size of F is changed. */
25877 cancel_mouse_face (struct frame
*f
)
25879 Lisp_Object window
;
25880 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25882 window
= hlinfo
->mouse_face_window
;
25883 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
25885 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
25886 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
25887 hlinfo
->mouse_face_window
= Qnil
;
25893 /***********************************************************************
25895 ***********************************************************************/
25897 #ifdef HAVE_WINDOW_SYSTEM
25899 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
25900 which intersects rectangle R. R is in window-relative coordinates. */
25903 expose_area (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
,
25904 enum glyph_row_area area
)
25906 struct glyph
*first
= row
->glyphs
[area
];
25907 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
25908 struct glyph
*last
;
25909 int first_x
, start_x
, x
;
25911 if (area
== TEXT_AREA
&& row
->fill_line_p
)
25912 /* If row extends face to end of line write the whole line. */
25913 draw_glyphs (w
, 0, row
, area
,
25914 0, row
->used
[area
],
25915 DRAW_NORMAL_TEXT
, 0);
25918 /* Set START_X to the window-relative start position for drawing glyphs of
25919 AREA. The first glyph of the text area can be partially visible.
25920 The first glyphs of other areas cannot. */
25921 start_x
= window_box_left_offset (w
, area
);
25923 if (area
== TEXT_AREA
)
25926 /* Find the first glyph that must be redrawn. */
25928 && x
+ first
->pixel_width
< r
->x
)
25930 x
+= first
->pixel_width
;
25934 /* Find the last one. */
25938 && x
< r
->x
+ r
->width
)
25940 x
+= last
->pixel_width
;
25946 draw_glyphs (w
, first_x
- start_x
, row
, area
,
25947 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
25948 DRAW_NORMAL_TEXT
, 0);
25953 /* Redraw the parts of the glyph row ROW on window W intersecting
25954 rectangle R. R is in window-relative coordinates. Value is
25955 non-zero if mouse-face was overwritten. */
25958 expose_line (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
)
25960 xassert (row
->enabled_p
);
25962 if (row
->mode_line_p
|| w
->pseudo_window_p
)
25963 draw_glyphs (w
, 0, row
, TEXT_AREA
,
25964 0, row
->used
[TEXT_AREA
],
25965 DRAW_NORMAL_TEXT
, 0);
25968 if (row
->used
[LEFT_MARGIN_AREA
])
25969 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
25970 if (row
->used
[TEXT_AREA
])
25971 expose_area (w
, row
, r
, TEXT_AREA
);
25972 if (row
->used
[RIGHT_MARGIN_AREA
])
25973 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
25974 draw_row_fringe_bitmaps (w
, row
);
25977 return row
->mouse_face_p
;
25981 /* Redraw those parts of glyphs rows during expose event handling that
25982 overlap other rows. Redrawing of an exposed line writes over parts
25983 of lines overlapping that exposed line; this function fixes that.
25985 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
25986 row in W's current matrix that is exposed and overlaps other rows.
25987 LAST_OVERLAPPING_ROW is the last such row. */
25990 expose_overlaps (struct window
*w
,
25991 struct glyph_row
*first_overlapping_row
,
25992 struct glyph_row
*last_overlapping_row
,
25995 struct glyph_row
*row
;
25997 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
25998 if (row
->overlapping_p
)
26000 xassert (row
->enabled_p
&& !row
->mode_line_p
);
26003 if (row
->used
[LEFT_MARGIN_AREA
])
26004 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
26006 if (row
->used
[TEXT_AREA
])
26007 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
26009 if (row
->used
[RIGHT_MARGIN_AREA
])
26010 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
26016 /* Return non-zero if W's cursor intersects rectangle R. */
26019 phys_cursor_in_rect_p (struct window
*w
, XRectangle
*r
)
26021 XRectangle cr
, result
;
26022 struct glyph
*cursor_glyph
;
26023 struct glyph_row
*row
;
26025 if (w
->phys_cursor
.vpos
>= 0
26026 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
26027 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
26029 && row
->cursor_in_fringe_p
)
26031 /* Cursor is in the fringe. */
26032 cr
.x
= window_box_right_offset (w
,
26033 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
26034 ? RIGHT_MARGIN_AREA
26037 cr
.width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
26038 cr
.height
= row
->height
;
26039 return x_intersect_rectangles (&cr
, r
, &result
);
26042 cursor_glyph
= get_phys_cursor_glyph (w
);
26045 /* r is relative to W's box, but w->phys_cursor.x is relative
26046 to left edge of W's TEXT area. Adjust it. */
26047 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
26048 cr
.y
= w
->phys_cursor
.y
;
26049 cr
.width
= cursor_glyph
->pixel_width
;
26050 cr
.height
= w
->phys_cursor_height
;
26051 /* ++KFS: W32 version used W32-specific IntersectRect here, but
26052 I assume the effect is the same -- and this is portable. */
26053 return x_intersect_rectangles (&cr
, r
, &result
);
26055 /* If we don't understand the format, pretend we're not in the hot-spot. */
26061 Draw a vertical window border to the right of window W if W doesn't
26062 have vertical scroll bars. */
26065 x_draw_vertical_border (struct window
*w
)
26067 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
26069 /* We could do better, if we knew what type of scroll-bar the adjacent
26070 windows (on either side) have... But we don't :-(
26071 However, I think this works ok. ++KFS 2003-04-25 */
26073 /* Redraw borders between horizontally adjacent windows. Don't
26074 do it for frames with vertical scroll bars because either the
26075 right scroll bar of a window, or the left scroll bar of its
26076 neighbor will suffice as a border. */
26077 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w
->frame
)))
26080 if (!WINDOW_RIGHTMOST_P (w
)
26081 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
26083 int x0
, x1
, y0
, y1
;
26085 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
26088 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
26091 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
26093 else if (!WINDOW_LEFTMOST_P (w
)
26094 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
26096 int x0
, x1
, y0
, y1
;
26098 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
26101 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
26104 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
26109 /* Redraw the part of window W intersection rectangle FR. Pixel
26110 coordinates in FR are frame-relative. Call this function with
26111 input blocked. Value is non-zero if the exposure overwrites
26115 expose_window (struct window
*w
, XRectangle
*fr
)
26117 struct frame
*f
= XFRAME (w
->frame
);
26119 int mouse_face_overwritten_p
= 0;
26121 /* If window is not yet fully initialized, do nothing. This can
26122 happen when toolkit scroll bars are used and a window is split.
26123 Reconfiguring the scroll bar will generate an expose for a newly
26125 if (w
->current_matrix
== NULL
)
26128 /* When we're currently updating the window, display and current
26129 matrix usually don't agree. Arrange for a thorough display
26131 if (w
== updated_window
)
26133 SET_FRAME_GARBAGED (f
);
26137 /* Frame-relative pixel rectangle of W. */
26138 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
26139 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
26140 wr
.width
= WINDOW_TOTAL_WIDTH (w
);
26141 wr
.height
= WINDOW_TOTAL_HEIGHT (w
);
26143 if (x_intersect_rectangles (fr
, &wr
, &r
))
26145 int yb
= window_text_bottom_y (w
);
26146 struct glyph_row
*row
;
26147 int cursor_cleared_p
;
26148 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
26150 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
26151 r
.x
, r
.y
, r
.width
, r
.height
));
26153 /* Convert to window coordinates. */
26154 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
26155 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
26157 /* Turn off the cursor. */
26158 if (!w
->pseudo_window_p
26159 && phys_cursor_in_rect_p (w
, &r
))
26161 x_clear_cursor (w
);
26162 cursor_cleared_p
= 1;
26165 cursor_cleared_p
= 0;
26167 /* Update lines intersecting rectangle R. */
26168 first_overlapping_row
= last_overlapping_row
= NULL
;
26169 for (row
= w
->current_matrix
->rows
;
26174 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
26176 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
26177 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
26178 || (r
.y
>= y0
&& r
.y
< y1
)
26179 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
26181 /* A header line may be overlapping, but there is no need
26182 to fix overlapping areas for them. KFS 2005-02-12 */
26183 if (row
->overlapping_p
&& !row
->mode_line_p
)
26185 if (first_overlapping_row
== NULL
)
26186 first_overlapping_row
= row
;
26187 last_overlapping_row
= row
;
26191 if (expose_line (w
, row
, &r
))
26192 mouse_face_overwritten_p
= 1;
26195 else if (row
->overlapping_p
)
26197 /* We must redraw a row overlapping the exposed area. */
26199 ? y0
+ row
->phys_height
> r
.y
26200 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
26202 if (first_overlapping_row
== NULL
)
26203 first_overlapping_row
= row
;
26204 last_overlapping_row
= row
;
26212 /* Display the mode line if there is one. */
26213 if (WINDOW_WANTS_MODELINE_P (w
)
26214 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
26216 && row
->y
< r
.y
+ r
.height
)
26218 if (expose_line (w
, row
, &r
))
26219 mouse_face_overwritten_p
= 1;
26222 if (!w
->pseudo_window_p
)
26224 /* Fix the display of overlapping rows. */
26225 if (first_overlapping_row
)
26226 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
26229 /* Draw border between windows. */
26230 x_draw_vertical_border (w
);
26232 /* Turn the cursor on again. */
26233 if (cursor_cleared_p
)
26234 update_window_cursor (w
, 1);
26238 return mouse_face_overwritten_p
;
26243 /* Redraw (parts) of all windows in the window tree rooted at W that
26244 intersect R. R contains frame pixel coordinates. Value is
26245 non-zero if the exposure overwrites mouse-face. */
26248 expose_window_tree (struct window
*w
, XRectangle
*r
)
26250 struct frame
*f
= XFRAME (w
->frame
);
26251 int mouse_face_overwritten_p
= 0;
26253 while (w
&& !FRAME_GARBAGED_P (f
))
26255 if (!NILP (w
->hchild
))
26256 mouse_face_overwritten_p
26257 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
26258 else if (!NILP (w
->vchild
))
26259 mouse_face_overwritten_p
26260 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
26262 mouse_face_overwritten_p
|= expose_window (w
, r
);
26264 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
26267 return mouse_face_overwritten_p
;
26272 Redisplay an exposed area of frame F. X and Y are the upper-left
26273 corner of the exposed rectangle. W and H are width and height of
26274 the exposed area. All are pixel values. W or H zero means redraw
26275 the entire frame. */
26278 expose_frame (struct frame
*f
, int x
, int y
, int w
, int h
)
26281 int mouse_face_overwritten_p
= 0;
26283 TRACE ((stderr
, "expose_frame "));
26285 /* No need to redraw if frame will be redrawn soon. */
26286 if (FRAME_GARBAGED_P (f
))
26288 TRACE ((stderr
, " garbaged\n"));
26292 /* If basic faces haven't been realized yet, there is no point in
26293 trying to redraw anything. This can happen when we get an expose
26294 event while Emacs is starting, e.g. by moving another window. */
26295 if (FRAME_FACE_CACHE (f
) == NULL
26296 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
26298 TRACE ((stderr
, " no faces\n"));
26302 if (w
== 0 || h
== 0)
26305 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
26306 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
26316 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
26317 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
26319 if (WINDOWP (f
->tool_bar_window
))
26320 mouse_face_overwritten_p
26321 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
26323 #ifdef HAVE_X_WINDOWS
26325 #ifndef USE_X_TOOLKIT
26326 if (WINDOWP (f
->menu_bar_window
))
26327 mouse_face_overwritten_p
26328 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
26329 #endif /* not USE_X_TOOLKIT */
26333 /* Some window managers support a focus-follows-mouse style with
26334 delayed raising of frames. Imagine a partially obscured frame,
26335 and moving the mouse into partially obscured mouse-face on that
26336 frame. The visible part of the mouse-face will be highlighted,
26337 then the WM raises the obscured frame. With at least one WM, KDE
26338 2.1, Emacs is not getting any event for the raising of the frame
26339 (even tried with SubstructureRedirectMask), only Expose events.
26340 These expose events will draw text normally, i.e. not
26341 highlighted. Which means we must redo the highlight here.
26342 Subsume it under ``we love X''. --gerd 2001-08-15 */
26343 /* Included in Windows version because Windows most likely does not
26344 do the right thing if any third party tool offers
26345 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
26346 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
26348 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
26349 if (f
== hlinfo
->mouse_face_mouse_frame
)
26351 int mouse_x
= hlinfo
->mouse_face_mouse_x
;
26352 int mouse_y
= hlinfo
->mouse_face_mouse_y
;
26353 clear_mouse_face (hlinfo
);
26354 note_mouse_highlight (f
, mouse_x
, mouse_y
);
26361 Determine the intersection of two rectangles R1 and R2. Return
26362 the intersection in *RESULT. Value is non-zero if RESULT is not
26366 x_intersect_rectangles (XRectangle
*r1
, XRectangle
*r2
, XRectangle
*result
)
26368 XRectangle
*left
, *right
;
26369 XRectangle
*upper
, *lower
;
26370 int intersection_p
= 0;
26372 /* Rearrange so that R1 is the left-most rectangle. */
26374 left
= r1
, right
= r2
;
26376 left
= r2
, right
= r1
;
26378 /* X0 of the intersection is right.x0, if this is inside R1,
26379 otherwise there is no intersection. */
26380 if (right
->x
<= left
->x
+ left
->width
)
26382 result
->x
= right
->x
;
26384 /* The right end of the intersection is the minimum of
26385 the right ends of left and right. */
26386 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
26389 /* Same game for Y. */
26391 upper
= r1
, lower
= r2
;
26393 upper
= r2
, lower
= r1
;
26395 /* The upper end of the intersection is lower.y0, if this is inside
26396 of upper. Otherwise, there is no intersection. */
26397 if (lower
->y
<= upper
->y
+ upper
->height
)
26399 result
->y
= lower
->y
;
26401 /* The lower end of the intersection is the minimum of the lower
26402 ends of upper and lower. */
26403 result
->height
= (min (lower
->y
+ lower
->height
,
26404 upper
->y
+ upper
->height
)
26406 intersection_p
= 1;
26410 return intersection_p
;
26413 #endif /* HAVE_WINDOW_SYSTEM */
26416 /***********************************************************************
26418 ***********************************************************************/
26421 syms_of_xdisp (void)
26423 Vwith_echo_area_save_vector
= Qnil
;
26424 staticpro (&Vwith_echo_area_save_vector
);
26426 Vmessage_stack
= Qnil
;
26427 staticpro (&Vmessage_stack
);
26429 Qinhibit_redisplay
= intern_c_string ("inhibit-redisplay");
26430 staticpro (&Qinhibit_redisplay
);
26432 message_dolog_marker1
= Fmake_marker ();
26433 staticpro (&message_dolog_marker1
);
26434 message_dolog_marker2
= Fmake_marker ();
26435 staticpro (&message_dolog_marker2
);
26436 message_dolog_marker3
= Fmake_marker ();
26437 staticpro (&message_dolog_marker3
);
26440 defsubr (&Sdump_frame_glyph_matrix
);
26441 defsubr (&Sdump_glyph_matrix
);
26442 defsubr (&Sdump_glyph_row
);
26443 defsubr (&Sdump_tool_bar_row
);
26444 defsubr (&Strace_redisplay
);
26445 defsubr (&Strace_to_stderr
);
26447 #ifdef HAVE_WINDOW_SYSTEM
26448 defsubr (&Stool_bar_lines_needed
);
26449 defsubr (&Slookup_image_map
);
26451 defsubr (&Sformat_mode_line
);
26452 defsubr (&Sinvisible_p
);
26453 defsubr (&Scurrent_bidi_paragraph_direction
);
26455 staticpro (&Qmenu_bar_update_hook
);
26456 Qmenu_bar_update_hook
= intern_c_string ("menu-bar-update-hook");
26458 staticpro (&Qoverriding_terminal_local_map
);
26459 Qoverriding_terminal_local_map
= intern_c_string ("overriding-terminal-local-map");
26461 staticpro (&Qoverriding_local_map
);
26462 Qoverriding_local_map
= intern_c_string ("overriding-local-map");
26464 staticpro (&Qwindow_scroll_functions
);
26465 Qwindow_scroll_functions
= intern_c_string ("window-scroll-functions");
26467 staticpro (&Qwindow_text_change_functions
);
26468 Qwindow_text_change_functions
= intern_c_string ("window-text-change-functions");
26470 staticpro (&Qredisplay_end_trigger_functions
);
26471 Qredisplay_end_trigger_functions
= intern_c_string ("redisplay-end-trigger-functions");
26473 staticpro (&Qinhibit_point_motion_hooks
);
26474 Qinhibit_point_motion_hooks
= intern_c_string ("inhibit-point-motion-hooks");
26476 Qeval
= intern_c_string ("eval");
26477 staticpro (&Qeval
);
26479 QCdata
= intern_c_string (":data");
26480 staticpro (&QCdata
);
26481 Qdisplay
= intern_c_string ("display");
26482 staticpro (&Qdisplay
);
26483 Qspace_width
= intern_c_string ("space-width");
26484 staticpro (&Qspace_width
);
26485 Qraise
= intern_c_string ("raise");
26486 staticpro (&Qraise
);
26487 Qslice
= intern_c_string ("slice");
26488 staticpro (&Qslice
);
26489 Qspace
= intern_c_string ("space");
26490 staticpro (&Qspace
);
26491 Qmargin
= intern_c_string ("margin");
26492 staticpro (&Qmargin
);
26493 Qpointer
= intern_c_string ("pointer");
26494 staticpro (&Qpointer
);
26495 Qleft_margin
= intern_c_string ("left-margin");
26496 staticpro (&Qleft_margin
);
26497 Qright_margin
= intern_c_string ("right-margin");
26498 staticpro (&Qright_margin
);
26499 Qcenter
= intern_c_string ("center");
26500 staticpro (&Qcenter
);
26501 Qline_height
= intern_c_string ("line-height");
26502 staticpro (&Qline_height
);
26503 QCalign_to
= intern_c_string (":align-to");
26504 staticpro (&QCalign_to
);
26505 QCrelative_width
= intern_c_string (":relative-width");
26506 staticpro (&QCrelative_width
);
26507 QCrelative_height
= intern_c_string (":relative-height");
26508 staticpro (&QCrelative_height
);
26509 QCeval
= intern_c_string (":eval");
26510 staticpro (&QCeval
);
26511 QCpropertize
= intern_c_string (":propertize");
26512 staticpro (&QCpropertize
);
26513 QCfile
= intern_c_string (":file");
26514 staticpro (&QCfile
);
26515 Qfontified
= intern_c_string ("fontified");
26516 staticpro (&Qfontified
);
26517 Qfontification_functions
= intern_c_string ("fontification-functions");
26518 staticpro (&Qfontification_functions
);
26519 Qtrailing_whitespace
= intern_c_string ("trailing-whitespace");
26520 staticpro (&Qtrailing_whitespace
);
26521 Qescape_glyph
= intern_c_string ("escape-glyph");
26522 staticpro (&Qescape_glyph
);
26523 Qnobreak_space
= intern_c_string ("nobreak-space");
26524 staticpro (&Qnobreak_space
);
26525 Qimage
= intern_c_string ("image");
26526 staticpro (&Qimage
);
26527 Qtext
= intern_c_string ("text");
26528 staticpro (&Qtext
);
26529 Qboth
= intern_c_string ("both");
26530 staticpro (&Qboth
);
26531 Qboth_horiz
= intern_c_string ("both-horiz");
26532 staticpro (&Qboth_horiz
);
26533 Qtext_image_horiz
= intern_c_string ("text-image-horiz");
26534 staticpro (&Qtext_image_horiz
);
26535 QCmap
= intern_c_string (":map");
26536 staticpro (&QCmap
);
26537 QCpointer
= intern_c_string (":pointer");
26538 staticpro (&QCpointer
);
26539 Qrect
= intern_c_string ("rect");
26540 staticpro (&Qrect
);
26541 Qcircle
= intern_c_string ("circle");
26542 staticpro (&Qcircle
);
26543 Qpoly
= intern_c_string ("poly");
26544 staticpro (&Qpoly
);
26545 Qmessage_truncate_lines
= intern_c_string ("message-truncate-lines");
26546 staticpro (&Qmessage_truncate_lines
);
26547 Qgrow_only
= intern_c_string ("grow-only");
26548 staticpro (&Qgrow_only
);
26549 Qinhibit_menubar_update
= intern_c_string ("inhibit-menubar-update");
26550 staticpro (&Qinhibit_menubar_update
);
26551 Qinhibit_eval_during_redisplay
= intern_c_string ("inhibit-eval-during-redisplay");
26552 staticpro (&Qinhibit_eval_during_redisplay
);
26553 Qposition
= intern_c_string ("position");
26554 staticpro (&Qposition
);
26555 Qbuffer_position
= intern_c_string ("buffer-position");
26556 staticpro (&Qbuffer_position
);
26557 Qobject
= intern_c_string ("object");
26558 staticpro (&Qobject
);
26559 Qbar
= intern_c_string ("bar");
26561 Qhbar
= intern_c_string ("hbar");
26562 staticpro (&Qhbar
);
26563 Qbox
= intern_c_string ("box");
26565 Qhollow
= intern_c_string ("hollow");
26566 staticpro (&Qhollow
);
26567 Qhand
= intern_c_string ("hand");
26568 staticpro (&Qhand
);
26569 Qarrow
= intern_c_string ("arrow");
26570 staticpro (&Qarrow
);
26571 Qtext
= intern_c_string ("text");
26572 staticpro (&Qtext
);
26573 Qinhibit_free_realized_faces
= intern_c_string ("inhibit-free-realized-faces");
26574 staticpro (&Qinhibit_free_realized_faces
);
26576 list_of_error
= Fcons (Fcons (intern_c_string ("error"),
26577 Fcons (intern_c_string ("void-variable"), Qnil
)),
26579 staticpro (&list_of_error
);
26581 Qlast_arrow_position
= intern_c_string ("last-arrow-position");
26582 staticpro (&Qlast_arrow_position
);
26583 Qlast_arrow_string
= intern_c_string ("last-arrow-string");
26584 staticpro (&Qlast_arrow_string
);
26586 Qoverlay_arrow_string
= intern_c_string ("overlay-arrow-string");
26587 staticpro (&Qoverlay_arrow_string
);
26588 Qoverlay_arrow_bitmap
= intern_c_string ("overlay-arrow-bitmap");
26589 staticpro (&Qoverlay_arrow_bitmap
);
26591 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
26592 staticpro (&echo_buffer
[0]);
26593 staticpro (&echo_buffer
[1]);
26595 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
26596 staticpro (&echo_area_buffer
[0]);
26597 staticpro (&echo_area_buffer
[1]);
26599 Vmessages_buffer_name
= make_pure_c_string ("*Messages*");
26600 staticpro (&Vmessages_buffer_name
);
26602 mode_line_proptrans_alist
= Qnil
;
26603 staticpro (&mode_line_proptrans_alist
);
26604 mode_line_string_list
= Qnil
;
26605 staticpro (&mode_line_string_list
);
26606 mode_line_string_face
= Qnil
;
26607 staticpro (&mode_line_string_face
);
26608 mode_line_string_face_prop
= Qnil
;
26609 staticpro (&mode_line_string_face_prop
);
26610 Vmode_line_unwind_vector
= Qnil
;
26611 staticpro (&Vmode_line_unwind_vector
);
26613 help_echo_string
= Qnil
;
26614 staticpro (&help_echo_string
);
26615 help_echo_object
= Qnil
;
26616 staticpro (&help_echo_object
);
26617 help_echo_window
= Qnil
;
26618 staticpro (&help_echo_window
);
26619 previous_help_echo_string
= Qnil
;
26620 staticpro (&previous_help_echo_string
);
26621 help_echo_pos
= -1;
26623 Qright_to_left
= intern_c_string ("right-to-left");
26624 staticpro (&Qright_to_left
);
26625 Qleft_to_right
= intern_c_string ("left-to-right");
26626 staticpro (&Qleft_to_right
);
26628 #ifdef HAVE_WINDOW_SYSTEM
26629 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p
,
26630 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
26631 For example, if a block cursor is over a tab, it will be drawn as
26632 wide as that tab on the display. */);
26633 x_stretch_cursor_p
= 0;
26636 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace
,
26637 doc
: /* *Non-nil means highlight trailing whitespace.
26638 The face used for trailing whitespace is `trailing-whitespace'. */);
26639 Vshow_trailing_whitespace
= Qnil
;
26641 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display
,
26642 doc
: /* *Control highlighting of nobreak space and soft hyphen.
26643 A value of t means highlight the character itself (for nobreak space,
26644 use face `nobreak-space').
26645 A value of nil means no highlighting.
26646 Other values mean display the escape glyph followed by an ordinary
26647 space or ordinary hyphen. */);
26648 Vnobreak_char_display
= Qt
;
26650 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer
,
26651 doc
: /* *The pointer shape to show in void text areas.
26652 A value of nil means to show the text pointer. Other options are `arrow',
26653 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
26654 Vvoid_text_area_pointer
= Qarrow
;
26656 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay
,
26657 doc
: /* Non-nil means don't actually do any redisplay.
26658 This is used for internal purposes. */);
26659 Vinhibit_redisplay
= Qnil
;
26661 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string
,
26662 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
26663 Vglobal_mode_string
= Qnil
;
26665 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position
,
26666 doc
: /* Marker for where to display an arrow on top of the buffer text.
26667 This must be the beginning of a line in order to work.
26668 See also `overlay-arrow-string'. */);
26669 Voverlay_arrow_position
= Qnil
;
26671 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string
,
26672 doc
: /* String to display as an arrow in non-window frames.
26673 See also `overlay-arrow-position'. */);
26674 Voverlay_arrow_string
= make_pure_c_string ("=>");
26676 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list
,
26677 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
26678 The symbols on this list are examined during redisplay to determine
26679 where to display overlay arrows. */);
26680 Voverlay_arrow_variable_list
26681 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil
);
26683 DEFVAR_INT ("scroll-step", emacs_scroll_step
,
26684 doc
: /* *The number of lines to try scrolling a window by when point moves out.
26685 If that fails to bring point back on frame, point is centered instead.
26686 If this is zero, point is always centered after it moves off frame.
26687 If you want scrolling to always be a line at a time, you should set
26688 `scroll-conservatively' to a large value rather than set this to 1. */);
26690 DEFVAR_INT ("scroll-conservatively", scroll_conservatively
,
26691 doc
: /* *Scroll up to this many lines, to bring point back on screen.
26692 If point moves off-screen, redisplay will scroll by up to
26693 `scroll-conservatively' lines in order to bring point just barely
26694 onto the screen again. If that cannot be done, then redisplay
26695 recenters point as usual.
26697 If the value is greater than 100, redisplay will never recenter point,
26698 but will always scroll just enough text to bring point into view, even
26699 if you move far away.
26701 A value of zero means always recenter point if it moves off screen. */);
26702 scroll_conservatively
= 0;
26704 DEFVAR_INT ("scroll-margin", scroll_margin
,
26705 doc
: /* *Number of lines of margin at the top and bottom of a window.
26706 Recenter the window whenever point gets within this many lines
26707 of the top or bottom of the window. */);
26710 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch
,
26711 doc
: /* Pixels per inch value for non-window system displays.
26712 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
26713 Vdisplay_pixels_per_inch
= make_float (72.0);
26716 DEFVAR_INT ("debug-end-pos", debug_end_pos
, doc
: /* Don't ask. */);
26719 DEFVAR_LISP ("truncate-partial-width-windows",
26720 Vtruncate_partial_width_windows
,
26721 doc
: /* Non-nil means truncate lines in windows narrower than the frame.
26722 For an integer value, truncate lines in each window narrower than the
26723 full frame width, provided the window width is less than that integer;
26724 otherwise, respect the value of `truncate-lines'.
26726 For any other non-nil value, truncate lines in all windows that do
26727 not span the full frame width.
26729 A value of nil means to respect the value of `truncate-lines'.
26731 If `word-wrap' is enabled, you might want to reduce this. */);
26732 Vtruncate_partial_width_windows
= make_number (50);
26734 DEFVAR_BOOL ("mode-line-inverse-video", mode_line_inverse_video
,
26735 doc
: /* When nil, display the mode-line/header-line/menu-bar in the default face.
26736 Any other value means to use the appropriate face, `mode-line',
26737 `header-line', or `menu' respectively. */);
26738 mode_line_inverse_video
= 1;
26740 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit
,
26741 doc
: /* *Maximum buffer size for which line number should be displayed.
26742 If the buffer is bigger than this, the line number does not appear
26743 in the mode line. A value of nil means no limit. */);
26744 Vline_number_display_limit
= Qnil
;
26746 DEFVAR_INT ("line-number-display-limit-width",
26747 line_number_display_limit_width
,
26748 doc
: /* *Maximum line width (in characters) for line number display.
26749 If the average length of the lines near point is bigger than this, then the
26750 line number may be omitted from the mode line. */);
26751 line_number_display_limit_width
= 200;
26753 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows
,
26754 doc
: /* *Non-nil means highlight region even in nonselected windows. */);
26755 highlight_nonselected_windows
= 0;
26757 DEFVAR_BOOL ("multiple-frames", multiple_frames
,
26758 doc
: /* Non-nil if more than one frame is visible on this display.
26759 Minibuffer-only frames don't count, but iconified frames do.
26760 This variable is not guaranteed to be accurate except while processing
26761 `frame-title-format' and `icon-title-format'. */);
26763 DEFVAR_LISP ("frame-title-format", Vframe_title_format
,
26764 doc
: /* Template for displaying the title bar of visible frames.
26765 \(Assuming the window manager supports this feature.)
26767 This variable has the same structure as `mode-line-format', except that
26768 the %c and %l constructs are ignored. It is used only on frames for
26769 which no explicit name has been set \(see `modify-frame-parameters'). */);
26771 DEFVAR_LISP ("icon-title-format", Vicon_title_format
,
26772 doc
: /* Template for displaying the title bar of an iconified frame.
26773 \(Assuming the window manager supports this feature.)
26774 This variable has the same structure as `mode-line-format' (which see),
26775 and is used only on frames for which no explicit name has been set
26776 \(see `modify-frame-parameters'). */);
26778 = Vframe_title_format
26779 = pure_cons (intern_c_string ("multiple-frames"),
26780 pure_cons (make_pure_c_string ("%b"),
26781 pure_cons (pure_cons (empty_unibyte_string
,
26782 pure_cons (intern_c_string ("invocation-name"),
26783 pure_cons (make_pure_c_string ("@"),
26784 pure_cons (intern_c_string ("system-name"),
26788 DEFVAR_LISP ("message-log-max", Vmessage_log_max
,
26789 doc
: /* Maximum number of lines to keep in the message log buffer.
26790 If nil, disable message logging. If t, log messages but don't truncate
26791 the buffer when it becomes large. */);
26792 Vmessage_log_max
= make_number (100);
26794 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions
,
26795 doc
: /* Functions called before redisplay, if window sizes have changed.
26796 The value should be a list of functions that take one argument.
26797 Just before redisplay, for each frame, if any of its windows have changed
26798 size since the last redisplay, or have been split or deleted,
26799 all the functions in the list are called, with the frame as argument. */);
26800 Vwindow_size_change_functions
= Qnil
;
26802 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions
,
26803 doc
: /* List of functions to call before redisplaying a window with scrolling.
26804 Each function is called with two arguments, the window and its new
26805 display-start position. Note that these functions are also called by
26806 `set-window-buffer'. Also note that the value of `window-end' is not
26807 valid when these functions are called. */);
26808 Vwindow_scroll_functions
= Qnil
;
26810 DEFVAR_LISP ("window-text-change-functions",
26811 Vwindow_text_change_functions
,
26812 doc
: /* Functions to call in redisplay when text in the window might change. */);
26813 Vwindow_text_change_functions
= Qnil
;
26815 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions
,
26816 doc
: /* Functions called when redisplay of a window reaches the end trigger.
26817 Each function is called with two arguments, the window and the end trigger value.
26818 See `set-window-redisplay-end-trigger'. */);
26819 Vredisplay_end_trigger_functions
= Qnil
;
26821 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window
,
26822 doc
: /* *Non-nil means autoselect window with mouse pointer.
26823 If nil, do not autoselect windows.
26824 A positive number means delay autoselection by that many seconds: a
26825 window is autoselected only after the mouse has remained in that
26826 window for the duration of the delay.
26827 A negative number has a similar effect, but causes windows to be
26828 autoselected only after the mouse has stopped moving. \(Because of
26829 the way Emacs compares mouse events, you will occasionally wait twice
26830 that time before the window gets selected.\)
26831 Any other value means to autoselect window instantaneously when the
26832 mouse pointer enters it.
26834 Autoselection selects the minibuffer only if it is active, and never
26835 unselects the minibuffer if it is active.
26837 When customizing this variable make sure that the actual value of
26838 `focus-follows-mouse' matches the behavior of your window manager. */);
26839 Vmouse_autoselect_window
= Qnil
;
26841 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars
,
26842 doc
: /* *Non-nil means automatically resize tool-bars.
26843 This dynamically changes the tool-bar's height to the minimum height
26844 that is needed to make all tool-bar items visible.
26845 If value is `grow-only', the tool-bar's height is only increased
26846 automatically; to decrease the tool-bar height, use \\[recenter]. */);
26847 Vauto_resize_tool_bars
= Qt
;
26849 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p
,
26850 doc
: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
26851 auto_raise_tool_bar_buttons_p
= 1;
26853 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p
,
26854 doc
: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
26855 make_cursor_line_fully_visible_p
= 1;
26857 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border
,
26858 doc
: /* *Border below tool-bar in pixels.
26859 If an integer, use it as the height of the border.
26860 If it is one of `internal-border-width' or `border-width', use the
26861 value of the corresponding frame parameter.
26862 Otherwise, no border is added below the tool-bar. */);
26863 Vtool_bar_border
= Qinternal_border_width
;
26865 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin
,
26866 doc
: /* *Margin around tool-bar buttons in pixels.
26867 If an integer, use that for both horizontal and vertical margins.
26868 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
26869 HORZ specifying the horizontal margin, and VERT specifying the
26870 vertical margin. */);
26871 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
26873 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief
,
26874 doc
: /* *Relief thickness of tool-bar buttons. */);
26875 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
26877 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style
,
26878 doc
: /* Tool bar style to use.
26880 image - show images only
26881 text - show text only
26882 both - show both, text below image
26883 both-horiz - show text to the right of the image
26884 text-image-horiz - show text to the left of the image
26885 any other - use system default or image if no system default. */);
26886 Vtool_bar_style
= Qnil
;
26888 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size
,
26889 doc
: /* *Maximum number of characters a label can have to be shown.
26890 The tool bar style must also show labels for this to have any effect, see
26891 `tool-bar-style'. */);
26892 tool_bar_max_label_size
= DEFAULT_TOOL_BAR_LABEL_SIZE
;
26894 DEFVAR_LISP ("fontification-functions", Vfontification_functions
,
26895 doc
: /* List of functions to call to fontify regions of text.
26896 Each function is called with one argument POS. Functions must
26897 fontify a region starting at POS in the current buffer, and give
26898 fontified regions the property `fontified'. */);
26899 Vfontification_functions
= Qnil
;
26900 Fmake_variable_buffer_local (Qfontification_functions
);
26902 DEFVAR_BOOL ("unibyte-display-via-language-environment",
26903 unibyte_display_via_language_environment
,
26904 doc
: /* *Non-nil means display unibyte text according to language environment.
26905 Specifically, this means that raw bytes in the range 160-255 decimal
26906 are displayed by converting them to the equivalent multibyte characters
26907 according to the current language environment. As a result, they are
26908 displayed according to the current fontset.
26910 Note that this variable affects only how these bytes are displayed,
26911 but does not change the fact they are interpreted as raw bytes. */);
26912 unibyte_display_via_language_environment
= 0;
26914 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height
,
26915 doc
: /* *Maximum height for resizing mini-windows.
26916 If a float, it specifies a fraction of the mini-window frame's height.
26917 If an integer, it specifies a number of lines. */);
26918 Vmax_mini_window_height
= make_float (0.25);
26920 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows
,
26921 doc
: /* *How to resize mini-windows.
26922 A value of nil means don't automatically resize mini-windows.
26923 A value of t means resize them to fit the text displayed in them.
26924 A value of `grow-only', the default, means let mini-windows grow
26925 only, until their display becomes empty, at which point the windows
26926 go back to their normal size. */);
26927 Vresize_mini_windows
= Qgrow_only
;
26929 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist
,
26930 doc
: /* Alist specifying how to blink the cursor off.
26931 Each element has the form (ON-STATE . OFF-STATE). Whenever the
26932 `cursor-type' frame-parameter or variable equals ON-STATE,
26933 comparing using `equal', Emacs uses OFF-STATE to specify
26934 how to blink it off. ON-STATE and OFF-STATE are values for
26935 the `cursor-type' frame parameter.
26937 If a frame's ON-STATE has no entry in this list,
26938 the frame's other specifications determine how to blink the cursor off. */);
26939 Vblink_cursor_alist
= Qnil
;
26941 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p
,
26942 doc
: /* Allow or disallow automatic horizontal scrolling of windows.
26943 If non-nil, windows are automatically scrolled horizontally to make
26944 point visible. */);
26945 automatic_hscrolling_p
= 1;
26946 Qauto_hscroll_mode
= intern_c_string ("auto-hscroll-mode");
26947 staticpro (&Qauto_hscroll_mode
);
26949 DEFVAR_INT ("hscroll-margin", hscroll_margin
,
26950 doc
: /* *How many columns away from the window edge point is allowed to get
26951 before automatic hscrolling will horizontally scroll the window. */);
26952 hscroll_margin
= 5;
26954 DEFVAR_LISP ("hscroll-step", Vhscroll_step
,
26955 doc
: /* *How many columns to scroll the window when point gets too close to the edge.
26956 When point is less than `hscroll-margin' columns from the window
26957 edge, automatic hscrolling will scroll the window by the amount of columns
26958 determined by this variable. If its value is a positive integer, scroll that
26959 many columns. If it's a positive floating-point number, it specifies the
26960 fraction of the window's width to scroll. If it's nil or zero, point will be
26961 centered horizontally after the scroll. Any other value, including negative
26962 numbers, are treated as if the value were zero.
26964 Automatic hscrolling always moves point outside the scroll margin, so if
26965 point was more than scroll step columns inside the margin, the window will
26966 scroll more than the value given by the scroll step.
26968 Note that the lower bound for automatic hscrolling specified by `scroll-left'
26969 and `scroll-right' overrides this variable's effect. */);
26970 Vhscroll_step
= make_number (0);
26972 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines
,
26973 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
26974 Bind this around calls to `message' to let it take effect. */);
26975 message_truncate_lines
= 0;
26977 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook
,
26978 doc
: /* Normal hook run to update the menu bar definitions.
26979 Redisplay runs this hook before it redisplays the menu bar.
26980 This is used to update submenus such as Buffers,
26981 whose contents depend on various data. */);
26982 Vmenu_bar_update_hook
= Qnil
;
26984 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame
,
26985 doc
: /* Frame for which we are updating a menu.
26986 The enable predicate for a menu binding should check this variable. */);
26987 Vmenu_updating_frame
= Qnil
;
26989 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update
,
26990 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
26991 inhibit_menubar_update
= 0;
26993 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix
,
26994 doc
: /* Prefix prepended to all continuation lines at display time.
26995 The value may be a string, an image, or a stretch-glyph; it is
26996 interpreted in the same way as the value of a `display' text property.
26998 This variable is overridden by any `wrap-prefix' text or overlay
27001 To add a prefix to non-continuation lines, use `line-prefix'. */);
27002 Vwrap_prefix
= Qnil
;
27003 staticpro (&Qwrap_prefix
);
27004 Qwrap_prefix
= intern_c_string ("wrap-prefix");
27005 Fmake_variable_buffer_local (Qwrap_prefix
);
27007 DEFVAR_LISP ("line-prefix", Vline_prefix
,
27008 doc
: /* Prefix prepended to all non-continuation lines at display time.
27009 The value may be a string, an image, or a stretch-glyph; it is
27010 interpreted in the same way as the value of a `display' text property.
27012 This variable is overridden by any `line-prefix' text or overlay
27015 To add a prefix to continuation lines, use `wrap-prefix'. */);
27016 Vline_prefix
= Qnil
;
27017 staticpro (&Qline_prefix
);
27018 Qline_prefix
= intern_c_string ("line-prefix");
27019 Fmake_variable_buffer_local (Qline_prefix
);
27021 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay
,
27022 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
27023 inhibit_eval_during_redisplay
= 0;
27025 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces
,
27026 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
27027 inhibit_free_realized_faces
= 0;
27030 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id
,
27031 doc
: /* Inhibit try_window_id display optimization. */);
27032 inhibit_try_window_id
= 0;
27034 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing
,
27035 doc
: /* Inhibit try_window_reusing display optimization. */);
27036 inhibit_try_window_reusing
= 0;
27038 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement
,
27039 doc
: /* Inhibit try_cursor_movement display optimization. */);
27040 inhibit_try_cursor_movement
= 0;
27041 #endif /* GLYPH_DEBUG */
27043 DEFVAR_INT ("overline-margin", overline_margin
,
27044 doc
: /* *Space between overline and text, in pixels.
27045 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
27046 margin to the caracter height. */);
27047 overline_margin
= 2;
27049 DEFVAR_INT ("underline-minimum-offset",
27050 underline_minimum_offset
,
27051 doc
: /* Minimum distance between baseline and underline.
27052 This can improve legibility of underlined text at small font sizes,
27053 particularly when using variable `x-use-underline-position-properties'
27054 with fonts that specify an UNDERLINE_POSITION relatively close to the
27055 baseline. The default value is 1. */);
27056 underline_minimum_offset
= 1;
27058 DEFVAR_BOOL ("display-hourglass", display_hourglass_p
,
27059 doc
: /* Non-nil means show an hourglass pointer, when Emacs is busy.
27060 This feature only works when on a window system that can change
27061 cursor shapes. */);
27062 display_hourglass_p
= 1;
27064 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay
,
27065 doc
: /* *Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
27066 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
27068 hourglass_atimer
= NULL
;
27069 hourglass_shown_p
= 0;
27071 DEFSYM (Qglyphless_char
, "glyphless-char");
27072 DEFSYM (Qhex_code
, "hex-code");
27073 DEFSYM (Qempty_box
, "empty-box");
27074 DEFSYM (Qthin_space
, "thin-space");
27075 DEFSYM (Qzero_width
, "zero-width");
27077 DEFSYM (Qglyphless_char_display
, "glyphless-char-display");
27078 /* Intern this now in case it isn't already done.
27079 Setting this variable twice is harmless.
27080 But don't staticpro it here--that is done in alloc.c. */
27081 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
27082 Fput (Qglyphless_char_display
, Qchar_table_extra_slots
, make_number (1));
27084 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display
,
27085 doc
: /* Char-table defining glyphless characters.
27086 Each element, if non-nil, should be one of the following:
27087 an ASCII acronym string: display this string in a box
27088 `hex-code': display the hexadecimal code of a character in a box
27089 `empty-box': display as an empty box
27090 `thin-space': display as 1-pixel width space
27091 `zero-width': don't display
27092 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
27093 display method for graphical terminals and text terminals respectively.
27094 GRAPHICAL and TEXT should each have one of the values listed above.
27096 The char-table has one extra slot to control the display of a character for
27097 which no font is found. This slot only takes effect on graphical terminals.
27098 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
27099 `thin-space'. The default is `empty-box'. */);
27100 Vglyphless_char_display
= Fmake_char_table (Qglyphless_char_display
, Qnil
);
27101 Fset_char_table_extra_slot (Vglyphless_char_display
, make_number (0),
27106 /* Initialize this module when Emacs starts. */
27111 current_header_line_height
= current_mode_line_height
= -1;
27113 CHARPOS (this_line_start_pos
) = 0;
27115 if (!noninteractive
)
27117 struct window
*m
= XWINDOW (minibuf_window
);
27118 Lisp_Object frame
= m
->frame
;
27119 struct frame
*f
= XFRAME (frame
);
27120 Lisp_Object root
= FRAME_ROOT_WINDOW (f
);
27121 struct window
*r
= XWINDOW (root
);
27124 echo_area_window
= minibuf_window
;
27126 XSETFASTINT (r
->top_line
, FRAME_TOP_MARGIN (f
));
27127 XSETFASTINT (r
->total_lines
, FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
));
27128 XSETFASTINT (r
->total_cols
, FRAME_COLS (f
));
27129 XSETFASTINT (m
->top_line
, FRAME_LINES (f
) - 1);
27130 XSETFASTINT (m
->total_lines
, 1);
27131 XSETFASTINT (m
->total_cols
, FRAME_COLS (f
));
27133 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
27134 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
27135 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
27137 /* The default ellipsis glyphs `...'. */
27138 for (i
= 0; i
< 3; ++i
)
27139 default_invis_vector
[i
] = make_number ('.');
27143 /* Allocate the buffer for frame titles.
27144 Also used for `format-mode-line'. */
27146 mode_line_noprop_buf
= (char *) xmalloc (size
);
27147 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
27148 mode_line_noprop_ptr
= mode_line_noprop_buf
;
27149 mode_line_target
= MODE_LINE_DISPLAY
;
27152 help_echo_showing_p
= 0;
27155 /* Since w32 does not support atimers, it defines its own implementation of
27156 the following three functions in w32fns.c. */
27159 /* Platform-independent portion of hourglass implementation. */
27161 /* Return non-zero if houglass timer has been started or hourglass is shown. */
27163 hourglass_started (void)
27165 return hourglass_shown_p
|| hourglass_atimer
!= NULL
;
27168 /* Cancel a currently active hourglass timer, and start a new one. */
27170 start_hourglass (void)
27172 #if defined (HAVE_WINDOW_SYSTEM)
27174 int secs
, usecs
= 0;
27176 cancel_hourglass ();
27178 if (INTEGERP (Vhourglass_delay
)
27179 && XINT (Vhourglass_delay
) > 0)
27180 secs
= XFASTINT (Vhourglass_delay
);
27181 else if (FLOATP (Vhourglass_delay
)
27182 && XFLOAT_DATA (Vhourglass_delay
) > 0)
27185 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
27186 secs
= XFASTINT (tem
);
27187 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
27190 secs
= DEFAULT_HOURGLASS_DELAY
;
27192 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
27193 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
27194 show_hourglass
, NULL
);
27199 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
27202 cancel_hourglass (void)
27204 #if defined (HAVE_WINDOW_SYSTEM)
27205 if (hourglass_atimer
)
27207 cancel_atimer (hourglass_atimer
);
27208 hourglass_atimer
= NULL
;
27211 if (hourglass_shown_p
)
27215 #endif /* ! WINDOWSNT */