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 passing it the buffer position where to start iteration. For
134 iteration over strings, pass -1 as the position to init_iterator,
135 and call reseat_to_string when the string is ready, to initialize
136 the iterator for that string. Thereafter, calls to
137 get_next_display_element fill the iterator structure with relevant
138 information about the next thing to display. Calls to
139 set_iterator_to_next move the iterator to the next thing.
141 Besides this, an iterator also contains information about the
142 display environment in which glyphs for display elements are to be
143 produced. It has fields for the width and height of the display,
144 the information whether long lines are truncated or continued, a
145 current X and Y position, and lots of other stuff you can better
148 Glyphs in a desired matrix are normally constructed in a loop
149 calling get_next_display_element and then PRODUCE_GLYPHS. The call
150 to PRODUCE_GLYPHS will fill the iterator structure with pixel
151 information about the element being displayed and at the same time
152 produce glyphs for it. If the display element fits on the line
153 being displayed, set_iterator_to_next is called next, otherwise the
154 glyphs produced are discarded. The function display_line is the
155 workhorse of filling glyph rows in the desired matrix with glyphs.
156 In addition to producing glyphs, it also handles line truncation
157 and continuation, word wrap, and cursor positioning (for the
158 latter, see also set_cursor_from_row).
162 That just couldn't be all, could it? What about terminal types not
163 supporting operations on sub-windows of the screen? To update the
164 display on such a terminal, window-based glyph matrices are not
165 well suited. To be able to reuse part of the display (scrolling
166 lines up and down), we must instead have a view of the whole
167 screen. This is what `frame matrices' are for. They are a trick.
169 Frames on terminals like above have a glyph pool. Windows on such
170 a frame sub-allocate their glyph memory from their frame's glyph
171 pool. The frame itself is given its own glyph matrices. By
172 coincidence---or maybe something else---rows in window glyph
173 matrices are slices of corresponding rows in frame matrices. Thus
174 writing to window matrices implicitly updates a frame matrix which
175 provides us with the view of the whole screen that we originally
176 wanted to have without having to move many bytes around. To be
177 honest, there is a little bit more done, but not much more. If you
178 plan to extend that code, take a look at dispnew.c. The function
179 build_frame_matrix is a good starting point.
181 Bidirectional display.
183 Bidirectional display adds quite some hair to this already complex
184 design. The good news are that a large portion of that hairy stuff
185 is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
186 reordering engine which is called by set_iterator_to_next and
187 returns the next character to display in the visual order. See
188 commentary on bidi.c for more details. As far as redisplay is
189 concerned, the effect of calling bidi_move_to_visually_next, the
190 main interface of the reordering engine, is that the iterator gets
191 magically placed on the buffer or string position that is to be
192 displayed next. In other words, a linear iteration through the
193 buffer/string is replaced with a non-linear one. All the rest of
194 the redisplay is oblivious to the bidi reordering.
196 Well, almost oblivious---there are still complications, most of
197 them due to the fact that buffer and string positions no longer
198 change monotonously with glyph indices in a glyph row. Moreover,
199 for continued lines, the buffer positions may not even be
200 monotonously changing with vertical positions. Also, accounting
201 for face changes, overlays, etc. becomes more complex because
202 non-linear iteration could potentially skip many positions with
203 changes, and then cross them again on the way back...
205 One other prominent effect of bidirectional display is that some
206 paragraphs of text need to be displayed starting at the right
207 margin of the window---the so-called right-to-left, or R2L
208 paragraphs. R2L paragraphs are displayed with R2L glyph rows,
209 which have their reversed_p flag set. The bidi reordering engine
210 produces characters in such rows starting from the character which
211 should be the rightmost on display. PRODUCE_GLYPHS then reverses
212 the order, when it fills up the glyph row whose reversed_p flag is
213 set, by prepending each new glyph to what is already there, instead
214 of appending it. When the glyph row is complete, the function
215 extend_face_to_end_of_line fills the empty space to the left of the
216 leftmost character with special glyphs, which will display as,
217 well, empty. On text terminals, these special glyphs are simply
218 blank characters. On graphics terminals, there's a single stretch
219 glyph of a suitably computed width. Both the blanks and the
220 stretch glyph are given the face of the background of the line.
221 This way, the terminal-specific back-end can still draw the glyphs
222 left to right, even for R2L lines.
224 Bidirectional display and character compositions
226 Some scripts cannot be displayed by drawing each character
227 individually, because adjacent characters change each other's shape
228 on display. For example, Arabic and Indic scripts belong to this
231 Emacs display supports this by providing "character compositions",
232 most of which is implemented in composite.c. During the buffer
233 scan that delivers characters to PRODUCE_GLYPHS, if the next
234 character to be delivered is a composed character, the iteration
235 calls composition_reseat_it and next_element_from_composition. If
236 they succeed to compose the character with one or more of the
237 following characters, the whole sequence of characters that where
238 composed is recorded in the `struct composition_it' object that is
239 part of the buffer iterator. The composed sequence could produce
240 one or more font glyphs (called "grapheme clusters") on the screen.
241 Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
242 in the direction corresponding to the current bidi scan direction
243 (recorded in the scan_dir member of the `struct bidi_it' object
244 that is part of the buffer iterator). In particular, if the bidi
245 iterator currently scans the buffer backwards, the grapheme
246 clusters are delivered back to front. This reorders the grapheme
247 clusters as appropriate for the current bidi context. Note that
248 this means that the grapheme clusters are always stored in the
249 LGSTRING object (see composite.c) in the logical order.
251 Moving an iterator in bidirectional text
252 without producing glyphs
254 Note one important detail mentioned above: that the bidi reordering
255 engine, driven by the iterator, produces characters in R2L rows
256 starting at the character that will be the rightmost on display.
257 As far as the iterator is concerned, the geometry of such rows is
258 still left to right, i.e. the iterator "thinks" the first character
259 is at the leftmost pixel position. The iterator does not know that
260 PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
261 delivers. This is important when functions from the the move_it_*
262 family are used to get to certain screen position or to match
263 screen coordinates with buffer coordinates: these functions use the
264 iterator geometry, which is left to right even in R2L paragraphs.
265 This works well with most callers of move_it_*, because they need
266 to get to a specific column, and columns are still numbered in the
267 reading order, i.e. the rightmost character in a R2L paragraph is
268 still column zero. But some callers do not get well with this; a
269 notable example is mouse clicks that need to find the character
270 that corresponds to certain pixel coordinates. See
271 buffer_posn_from_coords in dispnew.c for how this is handled. */
279 #include "keyboard.h"
282 #include "termchar.h"
283 #include "dispextern.h"
285 #include "character.h"
288 #include "commands.h"
292 #include "termhooks.h"
293 #include "termopts.h"
294 #include "intervals.h"
297 #include "region-cache.h"
300 #include "blockinput.h"
302 #ifdef HAVE_X_WINDOWS
317 #ifndef FRAME_X_OUTPUT
318 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
321 #define INFINITY 10000000
323 Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
324 Lisp_Object Qwindow_scroll_functions
;
325 static Lisp_Object Qwindow_text_change_functions
;
326 static Lisp_Object Qredisplay_end_trigger_functions
;
327 Lisp_Object Qinhibit_point_motion_hooks
;
328 static Lisp_Object QCeval
, QCpropertize
;
329 Lisp_Object QCfile
, QCdata
;
330 static Lisp_Object Qfontified
;
331 static Lisp_Object Qgrow_only
;
332 static Lisp_Object Qinhibit_eval_during_redisplay
;
333 static Lisp_Object Qbuffer_position
, Qposition
, Qobject
;
334 static Lisp_Object Qright_to_left
, Qleft_to_right
;
337 Lisp_Object Qbar
, Qhbar
, Qbox
, Qhollow
;
340 static Lisp_Object Qarrow
, Qhand
;
343 /* Holds the list (error). */
344 static Lisp_Object list_of_error
;
346 static Lisp_Object Qfontification_functions
;
348 static Lisp_Object Qwrap_prefix
;
349 static Lisp_Object Qline_prefix
;
351 /* Non-nil means don't actually do any redisplay. */
353 Lisp_Object Qinhibit_redisplay
;
355 /* Names of text properties relevant for redisplay. */
357 Lisp_Object Qdisplay
;
359 Lisp_Object Qspace
, QCalign_to
;
360 static Lisp_Object QCrelative_width
, QCrelative_height
;
361 Lisp_Object Qleft_margin
, Qright_margin
;
362 static Lisp_Object Qspace_width
, Qraise
;
363 static Lisp_Object Qslice
;
365 static Lisp_Object Qmargin
, Qpointer
;
366 static Lisp_Object Qline_height
;
368 #ifdef HAVE_WINDOW_SYSTEM
370 /* Test if overflow newline into fringe. Called with iterator IT
371 at or past right window margin, and with IT->current_x set. */
373 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT) \
374 (!NILP (Voverflow_newline_into_fringe) \
375 && FRAME_WINDOW_P ((IT)->f) \
376 && ((IT)->bidi_it.paragraph_dir == R2L \
377 ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0) \
378 : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0)) \
379 && (IT)->current_x == (IT)->last_visible_x \
380 && (IT)->line_wrap != WORD_WRAP)
382 #else /* !HAVE_WINDOW_SYSTEM */
383 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
384 #endif /* HAVE_WINDOW_SYSTEM */
386 /* Test if the display element loaded in IT is a space or tab
387 character. This is used to determine word wrapping. */
389 #define IT_DISPLAYING_WHITESPACE(it) \
390 (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
392 /* Name of the face used to highlight trailing whitespace. */
394 static Lisp_Object Qtrailing_whitespace
;
396 /* Name and number of the face used to highlight escape glyphs. */
398 static Lisp_Object Qescape_glyph
;
400 /* Name and number of the face used to highlight non-breaking spaces. */
402 static Lisp_Object Qnobreak_space
;
404 /* The symbol `image' which is the car of the lists used to represent
405 images in Lisp. Also a tool bar style. */
409 /* The image map types. */
411 static Lisp_Object QCpointer
;
412 static Lisp_Object Qrect
, Qcircle
, Qpoly
;
414 /* Tool bar styles */
415 Lisp_Object Qboth
, Qboth_horiz
, Qtext_image_horiz
;
417 /* Non-zero means print newline to stdout before next mini-buffer
420 int noninteractive_need_newline
;
422 /* Non-zero means print newline to message log before next message. */
424 static int message_log_need_newline
;
426 /* Three markers that message_dolog uses.
427 It could allocate them itself, but that causes trouble
428 in handling memory-full errors. */
429 static Lisp_Object message_dolog_marker1
;
430 static Lisp_Object message_dolog_marker2
;
431 static Lisp_Object message_dolog_marker3
;
433 /* The buffer position of the first character appearing entirely or
434 partially on the line of the selected window which contains the
435 cursor; <= 0 if not known. Set by set_cursor_from_row, used for
436 redisplay optimization in redisplay_internal. */
438 static struct text_pos this_line_start_pos
;
440 /* Number of characters past the end of the line above, including the
441 terminating newline. */
443 static struct text_pos this_line_end_pos
;
445 /* The vertical positions and the height of this line. */
447 static int this_line_vpos
;
448 static int this_line_y
;
449 static int this_line_pixel_height
;
451 /* X position at which this display line starts. Usually zero;
452 negative if first character is partially visible. */
454 static int this_line_start_x
;
456 /* The smallest character position seen by move_it_* functions as they
457 move across display lines. Used to set MATRIX_ROW_START_CHARPOS of
458 hscrolled lines, see display_line. */
460 static struct text_pos this_line_min_pos
;
462 /* Buffer that this_line_.* variables are referring to. */
464 static struct buffer
*this_line_buffer
;
467 /* Values of those variables at last redisplay are stored as
468 properties on `overlay-arrow-position' symbol. However, if
469 Voverlay_arrow_position is a marker, last-arrow-position is its
470 numerical position. */
472 static Lisp_Object Qlast_arrow_position
, Qlast_arrow_string
;
474 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
475 properties on a symbol in overlay-arrow-variable-list. */
477 static Lisp_Object Qoverlay_arrow_string
, Qoverlay_arrow_bitmap
;
479 Lisp_Object Qmenu_bar_update_hook
;
481 /* Nonzero if an overlay arrow has been displayed in this window. */
483 static int overlay_arrow_seen
;
485 /* Number of windows showing the buffer of the selected window (or
486 another buffer with the same base buffer). keyboard.c refers to
491 /* Vector containing glyphs for an ellipsis `...'. */
493 static Lisp_Object default_invis_vector
[3];
495 /* This is the window where the echo area message was displayed. It
496 is always a mini-buffer window, but it may not be the same window
497 currently active as a mini-buffer. */
499 Lisp_Object echo_area_window
;
501 /* List of pairs (MESSAGE . MULTIBYTE). The function save_message
502 pushes the current message and the value of
503 message_enable_multibyte on the stack, the function restore_message
504 pops the stack and displays MESSAGE again. */
506 static Lisp_Object Vmessage_stack
;
508 /* Nonzero means multibyte characters were enabled when the echo area
509 message was specified. */
511 static int message_enable_multibyte
;
513 /* Nonzero if we should redraw the mode lines on the next redisplay. */
515 int update_mode_lines
;
517 /* Nonzero if window sizes or contents have changed since last
518 redisplay that finished. */
520 int windows_or_buffers_changed
;
522 /* Nonzero means a frame's cursor type has been changed. */
524 int cursor_type_changed
;
526 /* Nonzero after display_mode_line if %l was used and it displayed a
529 static int line_number_displayed
;
531 /* The name of the *Messages* buffer, a string. */
533 static Lisp_Object Vmessages_buffer_name
;
535 /* Current, index 0, and last displayed echo area message. Either
536 buffers from echo_buffers, or nil to indicate no message. */
538 Lisp_Object echo_area_buffer
[2];
540 /* The buffers referenced from echo_area_buffer. */
542 static Lisp_Object echo_buffer
[2];
544 /* A vector saved used in with_area_buffer to reduce consing. */
546 static Lisp_Object Vwith_echo_area_save_vector
;
548 /* Non-zero means display_echo_area should display the last echo area
549 message again. Set by redisplay_preserve_echo_area. */
551 static int display_last_displayed_message_p
;
553 /* Nonzero if echo area is being used by print; zero if being used by
556 static int message_buf_print
;
558 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable. */
560 static Lisp_Object Qinhibit_menubar_update
;
561 static Lisp_Object Qmessage_truncate_lines
;
563 /* Set to 1 in clear_message to make redisplay_internal aware
564 of an emptied echo area. */
566 static int message_cleared_p
;
568 /* A scratch glyph row with contents used for generating truncation
569 glyphs. Also used in direct_output_for_insert. */
571 #define MAX_SCRATCH_GLYPHS 100
572 static struct glyph_row scratch_glyph_row
;
573 static struct glyph scratch_glyphs
[MAX_SCRATCH_GLYPHS
];
575 /* Ascent and height of the last line processed by move_it_to. */
577 static int last_max_ascent
, last_height
;
579 /* Non-zero if there's a help-echo in the echo area. */
581 int help_echo_showing_p
;
583 /* If >= 0, computed, exact values of mode-line and header-line height
584 to use in the macros CURRENT_MODE_LINE_HEIGHT and
585 CURRENT_HEADER_LINE_HEIGHT. */
587 int current_mode_line_height
, current_header_line_height
;
589 /* The maximum distance to look ahead for text properties. Values
590 that are too small let us call compute_char_face and similar
591 functions too often which is expensive. Values that are too large
592 let us call compute_char_face and alike too often because we
593 might not be interested in text properties that far away. */
595 #define TEXT_PROP_DISTANCE_LIMIT 100
597 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
598 iterator state and later restore it. This is needed because the
599 bidi iterator on bidi.c keeps a stacked cache of its states, which
600 is really a singleton. When we use scratch iterator objects to
601 move around the buffer, we can cause the bidi cache to be pushed or
602 popped, and therefore we need to restore the cache state when we
603 return to the original iterator. */
604 #define SAVE_IT(ITCOPY,ITORIG,CACHE) \
609 CACHE = bidi_shelve_cache(); \
612 #define RESTORE_IT(pITORIG,pITCOPY,CACHE) \
614 if (pITORIG != pITCOPY) \
615 *(pITORIG) = *(pITCOPY); \
616 bidi_unshelve_cache (CACHE); \
622 /* Non-zero means print traces of redisplay if compiled with
625 int trace_redisplay_p
;
627 #endif /* GLYPH_DEBUG */
629 #ifdef DEBUG_TRACE_MOVE
630 /* Non-zero means trace with TRACE_MOVE to stderr. */
633 #define TRACE_MOVE(x) if (trace_move) fprintf x; else (void) 0
635 #define TRACE_MOVE(x) (void) 0
638 static Lisp_Object Qauto_hscroll_mode
;
640 /* Buffer being redisplayed -- for redisplay_window_error. */
642 static struct buffer
*displayed_buffer
;
644 /* Value returned from text property handlers (see below). */
649 HANDLED_RECOMPUTE_PROPS
,
650 HANDLED_OVERLAY_STRING_CONSUMED
,
654 /* A description of text properties that redisplay is interested
659 /* The name of the property. */
662 /* A unique index for the property. */
665 /* A handler function called to set up iterator IT from the property
666 at IT's current position. Value is used to steer handle_stop. */
667 enum prop_handled (*handler
) (struct it
*it
);
670 static enum prop_handled
handle_face_prop (struct it
*);
671 static enum prop_handled
handle_invisible_prop (struct it
*);
672 static enum prop_handled
handle_display_prop (struct it
*);
673 static enum prop_handled
handle_composition_prop (struct it
*);
674 static enum prop_handled
handle_overlay_change (struct it
*);
675 static enum prop_handled
handle_fontified_prop (struct it
*);
677 /* Properties handled by iterators. */
679 static struct props it_props
[] =
681 {&Qfontified
, FONTIFIED_PROP_IDX
, handle_fontified_prop
},
682 /* Handle `face' before `display' because some sub-properties of
683 `display' need to know the face. */
684 {&Qface
, FACE_PROP_IDX
, handle_face_prop
},
685 {&Qdisplay
, DISPLAY_PROP_IDX
, handle_display_prop
},
686 {&Qinvisible
, INVISIBLE_PROP_IDX
, handle_invisible_prop
},
687 {&Qcomposition
, COMPOSITION_PROP_IDX
, handle_composition_prop
},
691 /* Value is the position described by X. If X is a marker, value is
692 the marker_position of X. Otherwise, value is X. */
694 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
696 /* Enumeration returned by some move_it_.* functions internally. */
700 /* Not used. Undefined value. */
703 /* Move ended at the requested buffer position or ZV. */
704 MOVE_POS_MATCH_OR_ZV
,
706 /* Move ended at the requested X pixel position. */
709 /* Move within a line ended at the end of a line that must be
713 /* Move within a line ended at the end of a line that would
714 be displayed truncated. */
717 /* Move within a line ended at a line end. */
721 /* This counter is used to clear the face cache every once in a while
722 in redisplay_internal. It is incremented for each redisplay.
723 Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
726 #define CLEAR_FACE_CACHE_COUNT 500
727 static int clear_face_cache_count
;
729 /* Similarly for the image cache. */
731 #ifdef HAVE_WINDOW_SYSTEM
732 #define CLEAR_IMAGE_CACHE_COUNT 101
733 static int clear_image_cache_count
;
735 /* Null glyph slice */
736 static struct glyph_slice null_glyph_slice
= { 0, 0, 0, 0 };
739 /* Non-zero while redisplay_internal is in progress. */
743 static Lisp_Object Qinhibit_free_realized_faces
;
745 /* If a string, XTread_socket generates an event to display that string.
746 (The display is done in read_char.) */
748 Lisp_Object help_echo_string
;
749 Lisp_Object help_echo_window
;
750 Lisp_Object help_echo_object
;
751 EMACS_INT help_echo_pos
;
753 /* Temporary variable for XTread_socket. */
755 Lisp_Object previous_help_echo_string
;
757 /* Platform-independent portion of hourglass implementation. */
759 /* Non-zero means an hourglass cursor is currently shown. */
760 int hourglass_shown_p
;
762 /* If non-null, an asynchronous timer that, when it expires, displays
763 an hourglass cursor on all frames. */
764 struct atimer
*hourglass_atimer
;
766 /* Name of the face used to display glyphless characters. */
767 Lisp_Object Qglyphless_char
;
769 /* Symbol for the purpose of Vglyphless_char_display. */
770 static Lisp_Object Qglyphless_char_display
;
772 /* Method symbols for Vglyphless_char_display. */
773 static Lisp_Object Qhex_code
, Qempty_box
, Qthin_space
, Qzero_width
;
775 /* Default pixel width of `thin-space' display method. */
776 #define THIN_SPACE_WIDTH 1
778 /* Default number of seconds to wait before displaying an hourglass
780 #define DEFAULT_HOURGLASS_DELAY 1
783 /* Function prototypes. */
785 static void setup_for_ellipsis (struct it
*, int);
786 static void set_iterator_to_next (struct it
*, int);
787 static void mark_window_display_accurate_1 (struct window
*, int);
788 static int single_display_spec_string_p (Lisp_Object
, Lisp_Object
);
789 static int display_prop_string_p (Lisp_Object
, Lisp_Object
);
790 static int cursor_row_p (struct glyph_row
*);
791 static int redisplay_mode_lines (Lisp_Object
, int);
792 static char *decode_mode_spec_coding (Lisp_Object
, char *, int);
794 static Lisp_Object
get_it_property (struct it
*it
, Lisp_Object prop
);
796 static void handle_line_prefix (struct it
*);
798 static void pint2str (char *, int, EMACS_INT
);
799 static void pint2hrstr (char *, int, EMACS_INT
);
800 static struct text_pos
run_window_scroll_functions (Lisp_Object
,
802 static void reconsider_clip_changes (struct window
*, struct buffer
*);
803 static int text_outside_line_unchanged_p (struct window
*,
804 EMACS_INT
, EMACS_INT
);
805 static void store_mode_line_noprop_char (char);
806 static int store_mode_line_noprop (const char *, int, int);
807 static void handle_stop (struct it
*);
808 static void handle_stop_backwards (struct it
*, EMACS_INT
);
809 static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0);
810 static void ensure_echo_area_buffers (void);
811 static Lisp_Object
unwind_with_echo_area_buffer (Lisp_Object
);
812 static Lisp_Object
with_echo_area_buffer_unwind_data (struct window
*);
813 static int with_echo_area_buffer (struct window
*, int,
814 int (*) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
815 EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
816 static void clear_garbaged_frames (void);
817 static int current_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
818 static void pop_message (void);
819 static int truncate_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
820 static void set_message (const char *, Lisp_Object
, EMACS_INT
, int);
821 static int set_message_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
822 static int display_echo_area (struct window
*);
823 static int display_echo_area_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
824 static int resize_mini_window_1 (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
);
825 static Lisp_Object
unwind_redisplay (Lisp_Object
);
826 static int string_char_and_length (const unsigned char *, int *);
827 static struct text_pos
display_prop_end (struct it
*, Lisp_Object
,
829 static int compute_window_start_on_continuation_line (struct window
*);
830 static Lisp_Object
safe_eval_handler (Lisp_Object
);
831 static void insert_left_trunc_glyphs (struct it
*);
832 static struct glyph_row
*get_overlay_arrow_glyph_row (struct window
*,
834 static void extend_face_to_end_of_line (struct it
*);
835 static int append_space_for_newline (struct it
*, int);
836 static int cursor_row_fully_visible_p (struct window
*, int, int);
837 static int try_scrolling (Lisp_Object
, int, EMACS_INT
, EMACS_INT
, int, int);
838 static int try_cursor_movement (Lisp_Object
, struct text_pos
, int *);
839 static int trailing_whitespace_p (EMACS_INT
);
840 static unsigned long int message_log_check_duplicate (EMACS_INT
, EMACS_INT
);
841 static void push_it (struct it
*, struct text_pos
*);
842 static void pop_it (struct it
*);
843 static void sync_frame_with_window_matrix_rows (struct window
*);
844 static void select_frame_for_redisplay (Lisp_Object
);
845 static void redisplay_internal (void);
846 static int echo_area_display (int);
847 static void redisplay_windows (Lisp_Object
);
848 static void redisplay_window (Lisp_Object
, int);
849 static Lisp_Object
redisplay_window_error (Lisp_Object
);
850 static Lisp_Object
redisplay_window_0 (Lisp_Object
);
851 static Lisp_Object
redisplay_window_1 (Lisp_Object
);
852 static int set_cursor_from_row (struct window
*, struct glyph_row
*,
853 struct glyph_matrix
*, EMACS_INT
, EMACS_INT
,
855 static int update_menu_bar (struct frame
*, int, int);
856 static int try_window_reusing_current_matrix (struct window
*);
857 static int try_window_id (struct window
*);
858 static int display_line (struct it
*);
859 static int display_mode_lines (struct window
*);
860 static int display_mode_line (struct window
*, enum face_id
, Lisp_Object
);
861 static int display_mode_element (struct it
*, int, int, int, Lisp_Object
, Lisp_Object
, int);
862 static int store_mode_line_string (const char *, Lisp_Object
, int, int, int, Lisp_Object
);
863 static const char *decode_mode_spec (struct window
*, int, int, Lisp_Object
*);
864 static void display_menu_bar (struct window
*);
865 static EMACS_INT
display_count_lines (EMACS_INT
, EMACS_INT
, EMACS_INT
,
867 static int display_string (const char *, Lisp_Object
, Lisp_Object
,
868 EMACS_INT
, EMACS_INT
, struct it
*, int, int, int, int);
869 static void compute_line_metrics (struct it
*);
870 static void run_redisplay_end_trigger_hook (struct it
*);
871 static int get_overlay_strings (struct it
*, EMACS_INT
);
872 static int get_overlay_strings_1 (struct it
*, EMACS_INT
, int);
873 static void next_overlay_string (struct it
*);
874 static void reseat (struct it
*, struct text_pos
, int);
875 static void reseat_1 (struct it
*, struct text_pos
, int);
876 static void back_to_previous_visible_line_start (struct it
*);
877 void reseat_at_previous_visible_line_start (struct it
*);
878 static void reseat_at_next_visible_line_start (struct it
*, int);
879 static int next_element_from_ellipsis (struct it
*);
880 static int next_element_from_display_vector (struct it
*);
881 static int next_element_from_string (struct it
*);
882 static int next_element_from_c_string (struct it
*);
883 static int next_element_from_buffer (struct it
*);
884 static int next_element_from_composition (struct it
*);
885 static int next_element_from_image (struct it
*);
886 static int next_element_from_stretch (struct it
*);
887 static void load_overlay_strings (struct it
*, EMACS_INT
);
888 static int init_from_display_pos (struct it
*, struct window
*,
889 struct display_pos
*);
890 static void reseat_to_string (struct it
*, const char *,
891 Lisp_Object
, EMACS_INT
, EMACS_INT
, int, int);
892 static int get_next_display_element (struct it
*);
893 static enum move_it_result
894 move_it_in_display_line_to (struct it
*, EMACS_INT
, int,
895 enum move_operation_enum
);
896 void move_it_vertically_backward (struct it
*, int);
897 static void init_to_row_start (struct it
*, struct window
*,
899 static int init_to_row_end (struct it
*, struct window
*,
901 static void back_to_previous_line_start (struct it
*);
902 static int forward_to_next_line_start (struct it
*, int *);
903 static struct text_pos
string_pos_nchars_ahead (struct text_pos
,
904 Lisp_Object
, EMACS_INT
);
905 static struct text_pos
string_pos (EMACS_INT
, Lisp_Object
);
906 static struct text_pos
c_string_pos (EMACS_INT
, const char *, int);
907 static EMACS_INT
number_of_chars (const char *, int);
908 static void compute_stop_pos (struct it
*);
909 static void compute_string_pos (struct text_pos
*, struct text_pos
,
911 static int face_before_or_after_it_pos (struct it
*, int);
912 static EMACS_INT
next_overlay_change (EMACS_INT
);
913 static int handle_display_spec (struct it
*, Lisp_Object
, Lisp_Object
,
914 Lisp_Object
, struct text_pos
*, EMACS_INT
, int);
915 static int handle_single_display_spec (struct it
*, Lisp_Object
,
916 Lisp_Object
, Lisp_Object
,
917 struct text_pos
*, EMACS_INT
, int, int);
918 static int underlying_face_id (struct it
*);
919 static int in_ellipses_for_invisible_text_p (struct display_pos
*,
922 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
923 #define face_after_it_pos(IT) face_before_or_after_it_pos ((IT), 0)
925 #ifdef HAVE_WINDOW_SYSTEM
927 static void x_consider_frame_title (Lisp_Object
);
928 static int tool_bar_lines_needed (struct frame
*, int *);
929 static void update_tool_bar (struct frame
*, int);
930 static void build_desired_tool_bar_string (struct frame
*f
);
931 static int redisplay_tool_bar (struct frame
*);
932 static void display_tool_bar_line (struct it
*, int);
933 static void notice_overwritten_cursor (struct window
*,
936 static void append_stretch_glyph (struct it
*, Lisp_Object
,
940 #endif /* HAVE_WINDOW_SYSTEM */
942 static void show_mouse_face (Mouse_HLInfo
*, enum draw_glyphs_face
);
943 static int coords_in_mouse_face_p (struct window
*, int, int);
947 /***********************************************************************
948 Window display dimensions
949 ***********************************************************************/
951 /* Return the bottom boundary y-position for text lines in window W.
952 This is the first y position at which a line cannot start.
953 It is relative to the top of the window.
955 This is the height of W minus the height of a mode line, if any. */
958 window_text_bottom_y (struct window
*w
)
960 int height
= WINDOW_TOTAL_HEIGHT (w
);
962 if (WINDOW_WANTS_MODELINE_P (w
))
963 height
-= CURRENT_MODE_LINE_HEIGHT (w
);
967 /* Return the pixel width of display area AREA of window W. AREA < 0
968 means return the total width of W, not including fringes to
969 the left and right of the window. */
972 window_box_width (struct window
*w
, int area
)
974 int cols
= XFASTINT (w
->total_cols
);
977 if (!w
->pseudo_window_p
)
979 cols
-= WINDOW_SCROLL_BAR_COLS (w
);
981 if (area
== TEXT_AREA
)
983 if (INTEGERP (w
->left_margin_cols
))
984 cols
-= XFASTINT (w
->left_margin_cols
);
985 if (INTEGERP (w
->right_margin_cols
))
986 cols
-= XFASTINT (w
->right_margin_cols
);
987 pixels
= -WINDOW_TOTAL_FRINGE_WIDTH (w
);
989 else if (area
== LEFT_MARGIN_AREA
)
991 cols
= (INTEGERP (w
->left_margin_cols
)
992 ? XFASTINT (w
->left_margin_cols
) : 0);
995 else if (area
== RIGHT_MARGIN_AREA
)
997 cols
= (INTEGERP (w
->right_margin_cols
)
998 ? XFASTINT (w
->right_margin_cols
) : 0);
1003 return cols
* WINDOW_FRAME_COLUMN_WIDTH (w
) + pixels
;
1007 /* Return the pixel height of the display area of window W, not
1008 including mode lines of W, if any. */
1011 window_box_height (struct window
*w
)
1013 struct frame
*f
= XFRAME (w
->frame
);
1014 int height
= WINDOW_TOTAL_HEIGHT (w
);
1016 xassert (height
>= 0);
1018 /* Note: the code below that determines the mode-line/header-line
1019 height is essentially the same as that contained in the macro
1020 CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
1021 the appropriate glyph row has its `mode_line_p' flag set,
1022 and if it doesn't, uses estimate_mode_line_height instead. */
1024 if (WINDOW_WANTS_MODELINE_P (w
))
1026 struct glyph_row
*ml_row
1027 = (w
->current_matrix
&& w
->current_matrix
->rows
1028 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
1030 if (ml_row
&& ml_row
->mode_line_p
)
1031 height
-= ml_row
->height
;
1033 height
-= estimate_mode_line_height (f
, CURRENT_MODE_LINE_FACE_ID (w
));
1036 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1038 struct glyph_row
*hl_row
1039 = (w
->current_matrix
&& w
->current_matrix
->rows
1040 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
1042 if (hl_row
&& hl_row
->mode_line_p
)
1043 height
-= hl_row
->height
;
1045 height
-= estimate_mode_line_height (f
, HEADER_LINE_FACE_ID
);
1048 /* With a very small font and a mode-line that's taller than
1049 default, we might end up with a negative height. */
1050 return max (0, height
);
1053 /* Return the window-relative coordinate of the left edge of display
1054 area AREA of window W. AREA < 0 means return the left edge of the
1055 whole window, to the right of the left fringe of W. */
1058 window_box_left_offset (struct window
*w
, int area
)
1062 if (w
->pseudo_window_p
)
1065 x
= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
1067 if (area
== TEXT_AREA
)
1068 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1069 + window_box_width (w
, LEFT_MARGIN_AREA
));
1070 else if (area
== RIGHT_MARGIN_AREA
)
1071 x
+= (WINDOW_LEFT_FRINGE_WIDTH (w
)
1072 + window_box_width (w
, LEFT_MARGIN_AREA
)
1073 + window_box_width (w
, TEXT_AREA
)
1074 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
1076 : WINDOW_RIGHT_FRINGE_WIDTH (w
)));
1077 else if (area
== LEFT_MARGIN_AREA
1078 && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
1079 x
+= WINDOW_LEFT_FRINGE_WIDTH (w
);
1085 /* Return the window-relative coordinate of the right edge of display
1086 area AREA of window W. AREA < 0 means return the right edge of the
1087 whole window, to the left of the right fringe of W. */
1090 window_box_right_offset (struct window
*w
, int area
)
1092 return window_box_left_offset (w
, area
) + window_box_width (w
, area
);
1095 /* Return the frame-relative coordinate of the left edge of display
1096 area AREA of window W. AREA < 0 means return the left edge of the
1097 whole window, to the right of the left fringe of W. */
1100 window_box_left (struct window
*w
, int area
)
1102 struct frame
*f
= XFRAME (w
->frame
);
1105 if (w
->pseudo_window_p
)
1106 return FRAME_INTERNAL_BORDER_WIDTH (f
);
1108 x
= (WINDOW_LEFT_EDGE_X (w
)
1109 + window_box_left_offset (w
, area
));
1115 /* Return the frame-relative coordinate of the right edge of display
1116 area AREA of window W. AREA < 0 means return the right edge of the
1117 whole window, to the left of the right fringe of W. */
1120 window_box_right (struct window
*w
, int area
)
1122 return window_box_left (w
, area
) + window_box_width (w
, area
);
1125 /* Get the bounding box of the display area AREA of window W, without
1126 mode lines, in frame-relative coordinates. AREA < 0 means the
1127 whole window, not including the left and right fringes of
1128 the window. Return in *BOX_X and *BOX_Y the frame-relative pixel
1129 coordinates of the upper-left corner of the box. Return in
1130 *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box. */
1133 window_box (struct window
*w
, int area
, int *box_x
, int *box_y
,
1134 int *box_width
, int *box_height
)
1137 *box_width
= window_box_width (w
, area
);
1139 *box_height
= window_box_height (w
);
1141 *box_x
= window_box_left (w
, area
);
1144 *box_y
= WINDOW_TOP_EDGE_Y (w
);
1145 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1146 *box_y
+= CURRENT_HEADER_LINE_HEIGHT (w
);
1151 /* Get the bounding box of the display area AREA of window W, without
1152 mode lines. AREA < 0 means the whole window, not including the
1153 left and right fringe of the window. Return in *TOP_LEFT_X
1154 and TOP_LEFT_Y the frame-relative pixel coordinates of the
1155 upper-left corner of the box. Return in *BOTTOM_RIGHT_X, and
1156 *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
1160 window_box_edges (struct window
*w
, int area
, int *top_left_x
, int *top_left_y
,
1161 int *bottom_right_x
, int *bottom_right_y
)
1163 window_box (w
, area
, top_left_x
, top_left_y
, bottom_right_x
,
1165 *bottom_right_x
+= *top_left_x
;
1166 *bottom_right_y
+= *top_left_y
;
1171 /***********************************************************************
1173 ***********************************************************************/
1175 /* Return the bottom y-position of the line the iterator IT is in.
1176 This can modify IT's settings. */
1179 line_bottom_y (struct it
*it
)
1181 int line_height
= it
->max_ascent
+ it
->max_descent
;
1182 int line_top_y
= it
->current_y
;
1184 if (line_height
== 0)
1187 line_height
= last_height
;
1188 else if (IT_CHARPOS (*it
) < ZV
)
1190 move_it_by_lines (it
, 1);
1191 line_height
= (it
->max_ascent
|| it
->max_descent
1192 ? it
->max_ascent
+ it
->max_descent
1197 struct glyph_row
*row
= it
->glyph_row
;
1199 /* Use the default character height. */
1200 it
->glyph_row
= NULL
;
1201 it
->what
= IT_CHARACTER
;
1204 PRODUCE_GLYPHS (it
);
1205 line_height
= it
->ascent
+ it
->descent
;
1206 it
->glyph_row
= row
;
1210 return line_top_y
+ line_height
;
1214 /* Return 1 if position CHARPOS is visible in window W.
1215 CHARPOS < 0 means return info about WINDOW_END position.
1216 If visible, set *X and *Y to pixel coordinates of top left corner.
1217 Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
1218 Set *ROWH and *VPOS to row's visible height and VPOS (row number). */
1221 pos_visible_p (struct window
*w
, EMACS_INT charpos
, int *x
, int *y
,
1222 int *rtop
, int *rbot
, int *rowh
, int *vpos
)
1225 void *itdata
= bidi_shelve_cache ();
1226 struct text_pos top
;
1228 struct buffer
*old_buffer
= NULL
;
1230 if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w
))))
1233 if (XBUFFER (w
->buffer
) != current_buffer
)
1235 old_buffer
= current_buffer
;
1236 set_buffer_internal_1 (XBUFFER (w
->buffer
));
1239 SET_TEXT_POS_FROM_MARKER (top
, w
->start
);
1241 /* Compute exact mode line heights. */
1242 if (WINDOW_WANTS_MODELINE_P (w
))
1243 current_mode_line_height
1244 = display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID (w
),
1245 BVAR (current_buffer
, mode_line_format
));
1247 if (WINDOW_WANTS_HEADER_LINE_P (w
))
1248 current_header_line_height
1249 = display_mode_line (w
, HEADER_LINE_FACE_ID
,
1250 BVAR (current_buffer
, header_line_format
));
1252 start_display (&it
, w
, top
);
1253 move_it_to (&it
, charpos
, -1, it
.last_visible_y
-1, -1,
1254 (charpos
>= 0 ? MOVE_TO_POS
: 0) | MOVE_TO_Y
);
1257 && (((!it
.bidi_p
|| it
.bidi_it
.scan_dir
== 1)
1258 && IT_CHARPOS (it
) >= charpos
)
1259 /* When scanning backwards under bidi iteration, move_it_to
1260 stops at or _before_ CHARPOS, because it stops at or to
1261 the _right_ of the character at CHARPOS. */
1262 || (it
.bidi_p
&& it
.bidi_it
.scan_dir
== -1
1263 && IT_CHARPOS (it
) <= charpos
)))
1265 /* We have reached CHARPOS, or passed it. How the call to
1266 move_it_to can overshoot: (i) If CHARPOS is on invisible text
1267 or covered by a display property, move_it_to stops at the end
1268 of the invisible text, to the right of CHARPOS. (ii) If
1269 CHARPOS is in a display vector, move_it_to stops on its last
1271 int top_x
= it
.current_x
;
1272 int top_y
= it
.current_y
;
1273 enum it_method it_method
= it
.method
;
1274 /* Calling line_bottom_y may change it.method, it.position, etc. */
1275 int bottom_y
= (last_height
= 0, line_bottom_y (&it
));
1276 int window_top_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1278 if (top_y
< window_top_y
)
1279 visible_p
= bottom_y
> window_top_y
;
1280 else if (top_y
< it
.last_visible_y
)
1284 if (it_method
== GET_FROM_DISPLAY_VECTOR
)
1286 /* We stopped on the last glyph of a display vector.
1287 Try and recompute. Hack alert! */
1288 if (charpos
< 2 || top
.charpos
>= charpos
)
1289 top_x
= it
.glyph_row
->x
;
1293 start_display (&it2
, w
, top
);
1294 move_it_to (&it2
, charpos
- 1, -1, -1, -1, MOVE_TO_POS
);
1295 get_next_display_element (&it2
);
1296 PRODUCE_GLYPHS (&it2
);
1297 if (ITERATOR_AT_END_OF_LINE_P (&it2
)
1298 || it2
.current_x
> it2
.last_visible_x
)
1299 top_x
= it
.glyph_row
->x
;
1302 top_x
= it2
.current_x
;
1303 top_y
= it2
.current_y
;
1309 *y
= max (top_y
+ max (0, it
.max_ascent
- it
.ascent
), window_top_y
);
1310 *rtop
= max (0, window_top_y
- top_y
);
1311 *rbot
= max (0, bottom_y
- it
.last_visible_y
);
1312 *rowh
= max (0, (min (bottom_y
, it
.last_visible_y
)
1313 - max (top_y
, window_top_y
)));
1319 /* We were asked to provide info about WINDOW_END. */
1321 void *it2data
= NULL
;
1323 SAVE_IT (it2
, it
, it2data
);
1324 if (IT_CHARPOS (it
) < ZV
&& FETCH_BYTE (IT_BYTEPOS (it
)) != '\n')
1325 move_it_by_lines (&it
, 1);
1326 if (charpos
< IT_CHARPOS (it
)
1327 || (it
.what
== IT_EOB
&& charpos
== IT_CHARPOS (it
)))
1330 RESTORE_IT (&it2
, &it2
, it2data
);
1331 move_it_to (&it2
, charpos
, -1, -1, -1, MOVE_TO_POS
);
1333 *y
= it2
.current_y
+ it2
.max_ascent
- it2
.ascent
;
1334 *rtop
= max (0, -it2
.current_y
);
1335 *rbot
= max (0, ((it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
)
1336 - it
.last_visible_y
));
1337 *rowh
= max (0, (min (it2
.current_y
+ it2
.max_ascent
+ it2
.max_descent
,
1339 - max (it2
.current_y
,
1340 WINDOW_HEADER_LINE_HEIGHT (w
))));
1346 bidi_unshelve_cache (itdata
);
1349 set_buffer_internal_1 (old_buffer
);
1351 current_header_line_height
= current_mode_line_height
= -1;
1353 if (visible_p
&& XFASTINT (w
->hscroll
) > 0)
1354 *x
-= XFASTINT (w
->hscroll
) * WINDOW_FRAME_COLUMN_WIDTH (w
);
1357 /* Debugging code. */
1359 fprintf (stderr
, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
1360 charpos
, w
->vscroll
, *x
, *y
, *rtop
, *rbot
, *rowh
, *vpos
);
1362 fprintf (stderr
, "-pv pt=%d vs=%d\n", charpos
, w
->vscroll
);
1369 /* Return the next character from STR. Return in *LEN the length of
1370 the character. This is like STRING_CHAR_AND_LENGTH but never
1371 returns an invalid character. If we find one, we return a `?', but
1372 with the length of the invalid character. */
1375 string_char_and_length (const unsigned char *str
, int *len
)
1379 c
= STRING_CHAR_AND_LENGTH (str
, *len
);
1380 if (!CHAR_VALID_P (c
, 1))
1381 /* We may not change the length here because other places in Emacs
1382 don't use this function, i.e. they silently accept invalid
1391 /* Given a position POS containing a valid character and byte position
1392 in STRING, return the position NCHARS ahead (NCHARS >= 0). */
1394 static struct text_pos
1395 string_pos_nchars_ahead (struct text_pos pos
, Lisp_Object string
, EMACS_INT nchars
)
1397 xassert (STRINGP (string
) && nchars
>= 0);
1399 if (STRING_MULTIBYTE (string
))
1401 const unsigned char *p
= SDATA (string
) + BYTEPOS (pos
);
1406 string_char_and_length (p
, &len
);
1409 BYTEPOS (pos
) += len
;
1413 SET_TEXT_POS (pos
, CHARPOS (pos
) + nchars
, BYTEPOS (pos
) + nchars
);
1419 /* Value is the text position, i.e. character and byte position,
1420 for character position CHARPOS in STRING. */
1422 static INLINE
struct text_pos
1423 string_pos (EMACS_INT charpos
, Lisp_Object string
)
1425 struct text_pos pos
;
1426 xassert (STRINGP (string
));
1427 xassert (charpos
>= 0);
1428 SET_TEXT_POS (pos
, charpos
, string_char_to_byte (string
, charpos
));
1433 /* Value is a text position, i.e. character and byte position, for
1434 character position CHARPOS in C string S. MULTIBYTE_P non-zero
1435 means recognize multibyte characters. */
1437 static struct text_pos
1438 c_string_pos (EMACS_INT charpos
, const char *s
, int multibyte_p
)
1440 struct text_pos pos
;
1442 xassert (s
!= NULL
);
1443 xassert (charpos
>= 0);
1449 SET_TEXT_POS (pos
, 0, 0);
1452 string_char_and_length ((const unsigned char *) s
, &len
);
1455 BYTEPOS (pos
) += len
;
1459 SET_TEXT_POS (pos
, charpos
, charpos
);
1465 /* Value is the number of characters in C string S. MULTIBYTE_P
1466 non-zero means recognize multibyte characters. */
1469 number_of_chars (const char *s
, int multibyte_p
)
1475 EMACS_INT rest
= strlen (s
);
1477 const unsigned char *p
= (const unsigned char *) s
;
1479 for (nchars
= 0; rest
> 0; ++nchars
)
1481 string_char_and_length (p
, &len
);
1482 rest
-= len
, p
+= len
;
1486 nchars
= strlen (s
);
1492 /* Compute byte position NEWPOS->bytepos corresponding to
1493 NEWPOS->charpos. POS is a known position in string STRING.
1494 NEWPOS->charpos must be >= POS.charpos. */
1497 compute_string_pos (struct text_pos
*newpos
, struct text_pos pos
, Lisp_Object string
)
1499 xassert (STRINGP (string
));
1500 xassert (CHARPOS (*newpos
) >= CHARPOS (pos
));
1502 if (STRING_MULTIBYTE (string
))
1503 *newpos
= string_pos_nchars_ahead (pos
, string
,
1504 CHARPOS (*newpos
) - CHARPOS (pos
));
1506 BYTEPOS (*newpos
) = CHARPOS (*newpos
);
1510 Return an estimation of the pixel height of mode or header lines on
1511 frame F. FACE_ID specifies what line's height to estimate. */
1514 estimate_mode_line_height (struct frame
*f
, enum face_id face_id
)
1516 #ifdef HAVE_WINDOW_SYSTEM
1517 if (FRAME_WINDOW_P (f
))
1519 int height
= FONT_HEIGHT (FRAME_FONT (f
));
1521 /* This function is called so early when Emacs starts that the face
1522 cache and mode line face are not yet initialized. */
1523 if (FRAME_FACE_CACHE (f
))
1525 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1529 height
= FONT_HEIGHT (face
->font
);
1530 if (face
->box_line_width
> 0)
1531 height
+= 2 * face
->box_line_width
;
1542 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
1543 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
1544 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
1545 not force the value into range. */
1548 pixel_to_glyph_coords (FRAME_PTR f
, register int pix_x
, register int pix_y
,
1549 int *x
, int *y
, NativeRectangle
*bounds
, int noclip
)
1552 #ifdef HAVE_WINDOW_SYSTEM
1553 if (FRAME_WINDOW_P (f
))
1555 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
1556 even for negative values. */
1558 pix_x
-= FRAME_COLUMN_WIDTH (f
) - 1;
1560 pix_y
-= FRAME_LINE_HEIGHT (f
) - 1;
1562 pix_x
= FRAME_PIXEL_X_TO_COL (f
, pix_x
);
1563 pix_y
= FRAME_PIXEL_Y_TO_LINE (f
, pix_y
);
1566 STORE_NATIVE_RECT (*bounds
,
1567 FRAME_COL_TO_PIXEL_X (f
, pix_x
),
1568 FRAME_LINE_TO_PIXEL_Y (f
, pix_y
),
1569 FRAME_COLUMN_WIDTH (f
) - 1,
1570 FRAME_LINE_HEIGHT (f
) - 1);
1576 else if (pix_x
> FRAME_TOTAL_COLS (f
))
1577 pix_x
= FRAME_TOTAL_COLS (f
);
1581 else if (pix_y
> FRAME_LINES (f
))
1582 pix_y
= FRAME_LINES (f
);
1592 /* Find the glyph under window-relative coordinates X/Y in window W.
1593 Consider only glyphs from buffer text, i.e. no glyphs from overlay
1594 strings. Return in *HPOS and *VPOS the row and column number of
1595 the glyph found. Return in *AREA the glyph area containing X.
1596 Value is a pointer to the glyph found or null if X/Y is not on
1597 text, or we can't tell because W's current matrix is not up to
1602 x_y_to_hpos_vpos (struct window
*w
, int x
, int y
, int *hpos
, int *vpos
,
1603 int *dx
, int *dy
, int *area
)
1605 struct glyph
*glyph
, *end
;
1606 struct glyph_row
*row
= NULL
;
1609 /* Find row containing Y. Give up if some row is not enabled. */
1610 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
1612 row
= MATRIX_ROW (w
->current_matrix
, i
);
1613 if (!row
->enabled_p
)
1615 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
1622 /* Give up if Y is not in the window. */
1623 if (i
== w
->current_matrix
->nrows
)
1626 /* Get the glyph area containing X. */
1627 if (w
->pseudo_window_p
)
1634 if (x
< window_box_left_offset (w
, TEXT_AREA
))
1636 *area
= LEFT_MARGIN_AREA
;
1637 x0
= window_box_left_offset (w
, LEFT_MARGIN_AREA
);
1639 else if (x
< window_box_right_offset (w
, TEXT_AREA
))
1642 x0
= window_box_left_offset (w
, TEXT_AREA
) + min (row
->x
, 0);
1646 *area
= RIGHT_MARGIN_AREA
;
1647 x0
= window_box_left_offset (w
, RIGHT_MARGIN_AREA
);
1651 /* Find glyph containing X. */
1652 glyph
= row
->glyphs
[*area
];
1653 end
= glyph
+ row
->used
[*area
];
1655 while (glyph
< end
&& x
>= glyph
->pixel_width
)
1657 x
-= glyph
->pixel_width
;
1667 *dy
= y
- (row
->y
+ row
->ascent
- glyph
->ascent
);
1670 *hpos
= glyph
- row
->glyphs
[*area
];
1674 /* Convert frame-relative x/y to coordinates relative to window W.
1675 Takes pseudo-windows into account. */
1678 frame_to_window_pixel_xy (struct window
*w
, int *x
, int *y
)
1680 if (w
->pseudo_window_p
)
1682 /* A pseudo-window is always full-width, and starts at the
1683 left edge of the frame, plus a frame border. */
1684 struct frame
*f
= XFRAME (w
->frame
);
1685 *x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
1686 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1690 *x
-= WINDOW_LEFT_EDGE_X (w
);
1691 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
1695 #ifdef HAVE_WINDOW_SYSTEM
1698 Return in RECTS[] at most N clipping rectangles for glyph string S.
1699 Return the number of stored rectangles. */
1702 get_glyph_string_clip_rects (struct glyph_string
*s
, NativeRectangle
*rects
, int n
)
1709 if (s
->row
->full_width_p
)
1711 /* Draw full-width. X coordinates are relative to S->w->left_col. */
1712 r
.x
= WINDOW_LEFT_EDGE_X (s
->w
);
1713 r
.width
= WINDOW_TOTAL_WIDTH (s
->w
);
1715 /* Unless displaying a mode or menu bar line, which are always
1716 fully visible, clip to the visible part of the row. */
1717 if (s
->w
->pseudo_window_p
)
1718 r
.height
= s
->row
->visible_height
;
1720 r
.height
= s
->height
;
1724 /* This is a text line that may be partially visible. */
1725 r
.x
= window_box_left (s
->w
, s
->area
);
1726 r
.width
= window_box_width (s
->w
, s
->area
);
1727 r
.height
= s
->row
->visible_height
;
1731 if (r
.x
< s
->clip_head
->x
)
1733 if (r
.width
>= s
->clip_head
->x
- r
.x
)
1734 r
.width
-= s
->clip_head
->x
- r
.x
;
1737 r
.x
= s
->clip_head
->x
;
1740 if (r
.x
+ r
.width
> s
->clip_tail
->x
+ s
->clip_tail
->background_width
)
1742 if (s
->clip_tail
->x
+ s
->clip_tail
->background_width
>= r
.x
)
1743 r
.width
= s
->clip_tail
->x
+ s
->clip_tail
->background_width
- r
.x
;
1748 /* If S draws overlapping rows, it's sufficient to use the top and
1749 bottom of the window for clipping because this glyph string
1750 intentionally draws over other lines. */
1751 if (s
->for_overlaps
)
1753 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1754 r
.height
= window_text_bottom_y (s
->w
) - r
.y
;
1756 /* Alas, the above simple strategy does not work for the
1757 environments with anti-aliased text: if the same text is
1758 drawn onto the same place multiple times, it gets thicker.
1759 If the overlap we are processing is for the erased cursor, we
1760 take the intersection with the rectagle of the cursor. */
1761 if (s
->for_overlaps
& OVERLAPS_ERASED_CURSOR
)
1763 XRectangle rc
, r_save
= r
;
1765 rc
.x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (s
->w
, s
->w
->phys_cursor
.x
);
1766 rc
.y
= s
->w
->phys_cursor
.y
;
1767 rc
.width
= s
->w
->phys_cursor_width
;
1768 rc
.height
= s
->w
->phys_cursor_height
;
1770 x_intersect_rectangles (&r_save
, &rc
, &r
);
1775 /* Don't use S->y for clipping because it doesn't take partially
1776 visible lines into account. For example, it can be negative for
1777 partially visible lines at the top of a window. */
1778 if (!s
->row
->full_width_p
1779 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
1780 r
.y
= WINDOW_HEADER_LINE_HEIGHT (s
->w
);
1782 r
.y
= max (0, s
->row
->y
);
1785 r
.y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
.y
);
1787 /* If drawing the cursor, don't let glyph draw outside its
1788 advertised boundaries. Cleartype does this under some circumstances. */
1789 if (s
->hl
== DRAW_CURSOR
)
1791 struct glyph
*glyph
= s
->first_glyph
;
1796 r
.width
-= s
->x
- r
.x
;
1799 r
.width
= min (r
.width
, glyph
->pixel_width
);
1801 /* If r.y is below window bottom, ensure that we still see a cursor. */
1802 height
= min (glyph
->ascent
+ glyph
->descent
,
1803 min (FRAME_LINE_HEIGHT (s
->f
), s
->row
->visible_height
));
1804 max_y
= window_text_bottom_y (s
->w
) - height
;
1805 max_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, max_y
);
1806 if (s
->ybase
- glyph
->ascent
> max_y
)
1813 /* Don't draw cursor glyph taller than our actual glyph. */
1814 height
= max (FRAME_LINE_HEIGHT (s
->f
), glyph
->ascent
+ glyph
->descent
);
1815 if (height
< r
.height
)
1817 max_y
= r
.y
+ r
.height
;
1818 r
.y
= min (max_y
, max (r
.y
, s
->ybase
+ glyph
->descent
- height
));
1819 r
.height
= min (max_y
- r
.y
, height
);
1826 XRectangle r_save
= r
;
1828 if (! x_intersect_rectangles (&r_save
, s
->row
->clip
, &r
))
1832 if ((s
->for_overlaps
& OVERLAPS_BOTH
) == 0
1833 || ((s
->for_overlaps
& OVERLAPS_BOTH
) == OVERLAPS_BOTH
&& n
== 1))
1835 #ifdef CONVERT_FROM_XRECT
1836 CONVERT_FROM_XRECT (r
, *rects
);
1844 /* If we are processing overlapping and allowed to return
1845 multiple clipping rectangles, we exclude the row of the glyph
1846 string from the clipping rectangle. This is to avoid drawing
1847 the same text on the environment with anti-aliasing. */
1848 #ifdef CONVERT_FROM_XRECT
1851 XRectangle
*rs
= rects
;
1853 int i
= 0, row_y
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, s
->row
->y
);
1855 if (s
->for_overlaps
& OVERLAPS_PRED
)
1858 if (r
.y
+ r
.height
> row_y
)
1861 rs
[i
].height
= row_y
- r
.y
;
1867 if (s
->for_overlaps
& OVERLAPS_SUCC
)
1870 if (r
.y
< row_y
+ s
->row
->visible_height
)
1872 if (r
.y
+ r
.height
> row_y
+ s
->row
->visible_height
)
1874 rs
[i
].y
= row_y
+ s
->row
->visible_height
;
1875 rs
[i
].height
= r
.y
+ r
.height
- rs
[i
].y
;
1884 #ifdef CONVERT_FROM_XRECT
1885 for (i
= 0; i
< n
; i
++)
1886 CONVERT_FROM_XRECT (rs
[i
], rects
[i
]);
1893 Return in *NR the clipping rectangle for glyph string S. */
1896 get_glyph_string_clip_rect (struct glyph_string
*s
, NativeRectangle
*nr
)
1898 get_glyph_string_clip_rects (s
, nr
, 1);
1903 Return the position and height of the phys cursor in window W.
1904 Set w->phys_cursor_width to width of phys cursor.
1908 get_phys_cursor_geometry (struct window
*w
, struct glyph_row
*row
,
1909 struct glyph
*glyph
, int *xp
, int *yp
, int *heightp
)
1911 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1912 int x
, y
, wd
, h
, h0
, y0
;
1914 /* Compute the width of the rectangle to draw. If on a stretch
1915 glyph, and `x-stretch-block-cursor' is nil, don't draw a
1916 rectangle as wide as the glyph, but use a canonical character
1918 wd
= glyph
->pixel_width
- 1;
1919 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
1923 x
= w
->phys_cursor
.x
;
1930 if (glyph
->type
== STRETCH_GLYPH
1931 && !x_stretch_cursor_p
)
1932 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
1933 w
->phys_cursor_width
= wd
;
1935 y
= w
->phys_cursor
.y
+ row
->ascent
- glyph
->ascent
;
1937 /* If y is below window bottom, ensure that we still see a cursor. */
1938 h0
= min (FRAME_LINE_HEIGHT (f
), row
->visible_height
);
1940 h
= max (h0
, glyph
->ascent
+ glyph
->descent
);
1941 h0
= min (h0
, glyph
->ascent
+ glyph
->descent
);
1943 y0
= WINDOW_HEADER_LINE_HEIGHT (w
);
1946 h
= max (h
- (y0
- y
) + 1, h0
);
1951 y0
= window_text_bottom_y (w
) - h0
;
1959 *xp
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, x
);
1960 *yp
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
);
1965 * Remember which glyph the mouse is over.
1969 remember_mouse_glyph (struct frame
*f
, int gx
, int gy
, NativeRectangle
*rect
)
1973 struct glyph_row
*r
, *gr
, *end_row
;
1974 enum window_part part
;
1975 enum glyph_row_area area
;
1976 int x
, y
, width
, height
;
1978 /* Try to determine frame pixel position and size of the glyph under
1979 frame pixel coordinates X/Y on frame F. */
1981 if (!f
->glyphs_initialized_p
1982 || (window
= window_from_coordinates (f
, gx
, gy
, &part
, 0),
1985 width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
1986 height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1990 w
= XWINDOW (window
);
1991 width
= WINDOW_FRAME_COLUMN_WIDTH (w
);
1992 height
= WINDOW_FRAME_LINE_HEIGHT (w
);
1994 x
= window_relative_x_coord (w
, part
, gx
);
1995 y
= gy
- WINDOW_TOP_EDGE_Y (w
);
1997 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
1998 end_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
2000 if (w
->pseudo_window_p
)
2003 part
= ON_MODE_LINE
; /* Don't adjust margin. */
2009 case ON_LEFT_MARGIN
:
2010 area
= LEFT_MARGIN_AREA
;
2013 case ON_RIGHT_MARGIN
:
2014 area
= RIGHT_MARGIN_AREA
;
2017 case ON_HEADER_LINE
:
2019 gr
= (part
== ON_HEADER_LINE
2020 ? MATRIX_HEADER_LINE_ROW (w
->current_matrix
)
2021 : MATRIX_MODE_LINE_ROW (w
->current_matrix
));
2024 goto text_glyph_row_found
;
2031 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2032 if (r
->y
+ r
->height
> y
)
2038 text_glyph_row_found
:
2041 struct glyph
*g
= gr
->glyphs
[area
];
2042 struct glyph
*end
= g
+ gr
->used
[area
];
2044 height
= gr
->height
;
2045 for (gx
= gr
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
2046 if (gx
+ g
->pixel_width
> x
)
2051 if (g
->type
== IMAGE_GLYPH
)
2053 /* Don't remember when mouse is over image, as
2054 image may have hot-spots. */
2055 STORE_NATIVE_RECT (*rect
, 0, 0, 0, 0);
2058 width
= g
->pixel_width
;
2062 /* Use nominal char spacing at end of line. */
2064 gx
+= (x
/ width
) * width
;
2067 if (part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
)
2068 gx
+= window_box_left_offset (w
, area
);
2072 /* Use nominal line height at end of window. */
2073 gx
= (x
/ width
) * width
;
2075 gy
+= (y
/ height
) * height
;
2079 case ON_LEFT_FRINGE
:
2080 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2081 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
)
2082 : window_box_right_offset (w
, LEFT_MARGIN_AREA
));
2083 width
= WINDOW_LEFT_FRINGE_WIDTH (w
);
2086 case ON_RIGHT_FRINGE
:
2087 gx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2088 ? window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2089 : window_box_right_offset (w
, TEXT_AREA
));
2090 width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
2094 gx
= (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
)
2096 : (window_box_right_offset (w
, RIGHT_MARGIN_AREA
)
2097 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
2098 ? WINDOW_RIGHT_FRINGE_WIDTH (w
)
2100 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
2104 for (; r
<= end_row
&& r
->enabled_p
; ++r
)
2105 if (r
->y
+ r
->height
> y
)
2112 height
= gr
->height
;
2115 /* Use nominal line height at end of window. */
2117 gy
+= (y
/ height
) * height
;
2124 /* If there is no glyph under the mouse, then we divide the screen
2125 into a grid of the smallest glyph in the frame, and use that
2128 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
2129 round down even for negative values. */
2135 gx
= (gx
/ width
) * width
;
2136 gy
= (gy
/ height
) * height
;
2141 gx
+= WINDOW_LEFT_EDGE_X (w
);
2142 gy
+= WINDOW_TOP_EDGE_Y (w
);
2145 STORE_NATIVE_RECT (*rect
, gx
, gy
, width
, height
);
2147 /* Visible feedback for debugging. */
2150 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2151 f
->output_data
.x
->normal_gc
,
2152 gx
, gy
, width
, height
);
2158 #endif /* HAVE_WINDOW_SYSTEM */
2161 /***********************************************************************
2162 Lisp form evaluation
2163 ***********************************************************************/
2165 /* Error handler for safe_eval and safe_call. */
2168 safe_eval_handler (Lisp_Object arg
)
2170 add_to_log ("Error during redisplay: %S", arg
, Qnil
);
2175 /* Evaluate SEXPR and return the result, or nil if something went
2176 wrong. Prevent redisplay during the evaluation. */
2178 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
2179 Return the result, or nil if something went wrong. Prevent
2180 redisplay during the evaluation. */
2183 safe_call (size_t nargs
, Lisp_Object
*args
)
2187 if (inhibit_eval_during_redisplay
)
2191 int count
= SPECPDL_INDEX ();
2192 struct gcpro gcpro1
;
2195 gcpro1
.nvars
= nargs
;
2196 specbind (Qinhibit_redisplay
, Qt
);
2197 /* Use Qt to ensure debugger does not run,
2198 so there is no possibility of wanting to redisplay. */
2199 val
= internal_condition_case_n (Ffuncall
, nargs
, args
, Qt
,
2202 val
= unbind_to (count
, val
);
2209 /* Call function FN with one argument ARG.
2210 Return the result, or nil if something went wrong. */
2213 safe_call1 (Lisp_Object fn
, Lisp_Object arg
)
2215 Lisp_Object args
[2];
2218 return safe_call (2, args
);
2221 static Lisp_Object Qeval
;
2224 safe_eval (Lisp_Object sexpr
)
2226 return safe_call1 (Qeval
, sexpr
);
2229 /* Call function FN with one argument ARG.
2230 Return the result, or nil if something went wrong. */
2233 safe_call2 (Lisp_Object fn
, Lisp_Object arg1
, Lisp_Object arg2
)
2235 Lisp_Object args
[3];
2239 return safe_call (3, args
);
2244 /***********************************************************************
2246 ***********************************************************************/
2250 /* Define CHECK_IT to perform sanity checks on iterators.
2251 This is for debugging. It is too slow to do unconditionally. */
2257 if (it
->method
== GET_FROM_STRING
)
2259 xassert (STRINGP (it
->string
));
2260 xassert (IT_STRING_CHARPOS (*it
) >= 0);
2264 xassert (IT_STRING_CHARPOS (*it
) < 0);
2265 if (it
->method
== GET_FROM_BUFFER
)
2267 /* Check that character and byte positions agree. */
2268 xassert (IT_CHARPOS (*it
) == BYTE_TO_CHAR (IT_BYTEPOS (*it
)));
2273 xassert (it
->current
.dpvec_index
>= 0);
2275 xassert (it
->current
.dpvec_index
< 0);
2278 #define CHECK_IT(IT) check_it ((IT))
2282 #define CHECK_IT(IT) (void) 0
2289 /* Check that the window end of window W is what we expect it
2290 to be---the last row in the current matrix displaying text. */
2293 check_window_end (w
)
2296 if (!MINI_WINDOW_P (w
)
2297 && !NILP (w
->window_end_valid
))
2299 struct glyph_row
*row
;
2300 xassert ((row
= MATRIX_ROW (w
->current_matrix
,
2301 XFASTINT (w
->window_end_vpos
)),
2303 || MATRIX_ROW_DISPLAYS_TEXT_P (row
)
2304 || MATRIX_ROW_VPOS (row
, w
->current_matrix
) == 0));
2308 #define CHECK_WINDOW_END(W) check_window_end ((W))
2310 #else /* not GLYPH_DEBUG */
2312 #define CHECK_WINDOW_END(W) (void) 0
2314 #endif /* not GLYPH_DEBUG */
2318 /***********************************************************************
2319 Iterator initialization
2320 ***********************************************************************/
2322 /* Initialize IT for displaying current_buffer in window W, starting
2323 at character position CHARPOS. CHARPOS < 0 means that no buffer
2324 position is specified which is useful when the iterator is assigned
2325 a position later. BYTEPOS is the byte position corresponding to
2326 CHARPOS. BYTEPOS < 0 means compute it from CHARPOS.
2328 If ROW is not null, calls to produce_glyphs with IT as parameter
2329 will produce glyphs in that row.
2331 BASE_FACE_ID is the id of a base face to use. It must be one of
2332 DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
2333 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
2334 mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
2336 If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
2337 MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
2338 will be initialized to use the corresponding mode line glyph row of
2339 the desired matrix of W. */
2342 init_iterator (struct it
*it
, struct window
*w
,
2343 EMACS_INT charpos
, EMACS_INT bytepos
,
2344 struct glyph_row
*row
, enum face_id base_face_id
)
2346 int highlight_region_p
;
2347 enum face_id remapped_base_face_id
= base_face_id
;
2349 /* Some precondition checks. */
2350 xassert (w
!= NULL
&& it
!= NULL
);
2351 xassert (charpos
< 0 || (charpos
>= BUF_BEG (current_buffer
)
2354 /* If face attributes have been changed since the last redisplay,
2355 free realized faces now because they depend on face definitions
2356 that might have changed. Don't free faces while there might be
2357 desired matrices pending which reference these faces. */
2358 if (face_change_count
&& !inhibit_free_realized_faces
)
2360 face_change_count
= 0;
2361 free_all_realized_faces (Qnil
);
2364 /* Perhaps remap BASE_FACE_ID to a user-specified alternative. */
2365 if (! NILP (Vface_remapping_alist
))
2366 remapped_base_face_id
= lookup_basic_face (XFRAME (w
->frame
), base_face_id
);
2368 /* Use one of the mode line rows of W's desired matrix if
2372 if (base_face_id
== MODE_LINE_FACE_ID
2373 || base_face_id
== MODE_LINE_INACTIVE_FACE_ID
)
2374 row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
2375 else if (base_face_id
== HEADER_LINE_FACE_ID
)
2376 row
= MATRIX_HEADER_LINE_ROW (w
->desired_matrix
);
2380 memset (it
, 0, sizeof *it
);
2381 it
->current
.overlay_string_index
= -1;
2382 it
->current
.dpvec_index
= -1;
2383 it
->base_face_id
= remapped_base_face_id
;
2385 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
2386 it
->paragraph_embedding
= L2R
;
2387 it
->bidi_it
.string
.lstring
= Qnil
;
2388 it
->bidi_it
.string
.s
= NULL
;
2389 it
->bidi_it
.string
.bufpos
= 0;
2391 /* The window in which we iterate over current_buffer: */
2392 XSETWINDOW (it
->window
, w
);
2394 it
->f
= XFRAME (w
->frame
);
2398 /* Extra space between lines (on window systems only). */
2399 if (base_face_id
== DEFAULT_FACE_ID
2400 && FRAME_WINDOW_P (it
->f
))
2402 if (NATNUMP (BVAR (current_buffer
, extra_line_spacing
)))
2403 it
->extra_line_spacing
= XFASTINT (BVAR (current_buffer
, extra_line_spacing
));
2404 else if (FLOATP (BVAR (current_buffer
, extra_line_spacing
)))
2405 it
->extra_line_spacing
= (XFLOAT_DATA (BVAR (current_buffer
, extra_line_spacing
))
2406 * FRAME_LINE_HEIGHT (it
->f
));
2407 else if (it
->f
->extra_line_spacing
> 0)
2408 it
->extra_line_spacing
= it
->f
->extra_line_spacing
;
2409 it
->max_extra_line_spacing
= 0;
2412 /* If realized faces have been removed, e.g. because of face
2413 attribute changes of named faces, recompute them. When running
2414 in batch mode, the face cache of the initial frame is null. If
2415 we happen to get called, make a dummy face cache. */
2416 if (FRAME_FACE_CACHE (it
->f
) == NULL
)
2417 init_frame_faces (it
->f
);
2418 if (FRAME_FACE_CACHE (it
->f
)->used
== 0)
2419 recompute_basic_faces (it
->f
);
2421 /* Current value of the `slice', `space-width', and 'height' properties. */
2422 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
2423 it
->space_width
= Qnil
;
2424 it
->font_height
= Qnil
;
2425 it
->override_ascent
= -1;
2427 /* Are control characters displayed as `^C'? */
2428 it
->ctl_arrow_p
= !NILP (BVAR (current_buffer
, ctl_arrow
));
2430 /* -1 means everything between a CR and the following line end
2431 is invisible. >0 means lines indented more than this value are
2433 it
->selective
= (INTEGERP (BVAR (current_buffer
, selective_display
))
2434 ? XFASTINT (BVAR (current_buffer
, selective_display
))
2435 : (!NILP (BVAR (current_buffer
, selective_display
))
2437 it
->selective_display_ellipsis_p
2438 = !NILP (BVAR (current_buffer
, selective_display_ellipses
));
2440 /* Display table to use. */
2441 it
->dp
= window_display_table (w
);
2443 /* Are multibyte characters enabled in current_buffer? */
2444 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
2446 /* Non-zero if we should highlight the region. */
2448 = (!NILP (Vtransient_mark_mode
)
2449 && !NILP (BVAR (current_buffer
, mark_active
))
2450 && XMARKER (BVAR (current_buffer
, mark
))->buffer
!= 0);
2452 /* Set IT->region_beg_charpos and IT->region_end_charpos to the
2453 start and end of a visible region in window IT->w. Set both to
2454 -1 to indicate no region. */
2455 if (highlight_region_p
2456 /* Maybe highlight only in selected window. */
2457 && (/* Either show region everywhere. */
2458 highlight_nonselected_windows
2459 /* Or show region in the selected window. */
2460 || w
== XWINDOW (selected_window
)
2461 /* Or show the region if we are in the mini-buffer and W is
2462 the window the mini-buffer refers to. */
2463 || (MINI_WINDOW_P (XWINDOW (selected_window
))
2464 && WINDOWP (minibuf_selected_window
)
2465 && w
== XWINDOW (minibuf_selected_window
))))
2467 EMACS_INT markpos
= marker_position (BVAR (current_buffer
, mark
));
2468 it
->region_beg_charpos
= min (PT
, markpos
);
2469 it
->region_end_charpos
= max (PT
, markpos
);
2472 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
2474 /* Get the position at which the redisplay_end_trigger hook should
2475 be run, if it is to be run at all. */
2476 if (MARKERP (w
->redisplay_end_trigger
)
2477 && XMARKER (w
->redisplay_end_trigger
)->buffer
!= 0)
2478 it
->redisplay_end_trigger_charpos
2479 = marker_position (w
->redisplay_end_trigger
);
2480 else if (INTEGERP (w
->redisplay_end_trigger
))
2481 it
->redisplay_end_trigger_charpos
= XINT (w
->redisplay_end_trigger
);
2483 /* Correct bogus values of tab_width. */
2484 it
->tab_width
= XINT (BVAR (current_buffer
, tab_width
));
2485 if (it
->tab_width
<= 0 || it
->tab_width
> 1000)
2488 /* Are lines in the display truncated? */
2489 if (base_face_id
!= DEFAULT_FACE_ID
2490 || XINT (it
->w
->hscroll
)
2491 || (! WINDOW_FULL_WIDTH_P (it
->w
)
2492 && ((!NILP (Vtruncate_partial_width_windows
)
2493 && !INTEGERP (Vtruncate_partial_width_windows
))
2494 || (INTEGERP (Vtruncate_partial_width_windows
)
2495 && (WINDOW_TOTAL_COLS (it
->w
)
2496 < XINT (Vtruncate_partial_width_windows
))))))
2497 it
->line_wrap
= TRUNCATE
;
2498 else if (NILP (BVAR (current_buffer
, truncate_lines
)))
2499 it
->line_wrap
= NILP (BVAR (current_buffer
, word_wrap
))
2500 ? WINDOW_WRAP
: WORD_WRAP
;
2502 it
->line_wrap
= TRUNCATE
;
2504 /* Get dimensions of truncation and continuation glyphs. These are
2505 displayed as fringe bitmaps under X, so we don't need them for such
2507 if (!FRAME_WINDOW_P (it
->f
))
2509 if (it
->line_wrap
== TRUNCATE
)
2511 /* We will need the truncation glyph. */
2512 xassert (it
->glyph_row
== NULL
);
2513 produce_special_glyphs (it
, IT_TRUNCATION
);
2514 it
->truncation_pixel_width
= it
->pixel_width
;
2518 /* We will need the continuation glyph. */
2519 xassert (it
->glyph_row
== NULL
);
2520 produce_special_glyphs (it
, IT_CONTINUATION
);
2521 it
->continuation_pixel_width
= it
->pixel_width
;
2524 /* Reset these values to zero because the produce_special_glyphs
2525 above has changed them. */
2526 it
->pixel_width
= it
->ascent
= it
->descent
= 0;
2527 it
->phys_ascent
= it
->phys_descent
= 0;
2530 /* Set this after getting the dimensions of truncation and
2531 continuation glyphs, so that we don't produce glyphs when calling
2532 produce_special_glyphs, above. */
2533 it
->glyph_row
= row
;
2534 it
->area
= TEXT_AREA
;
2536 /* Forget any previous info about this row being reversed. */
2538 it
->glyph_row
->reversed_p
= 0;
2540 /* Get the dimensions of the display area. The display area
2541 consists of the visible window area plus a horizontally scrolled
2542 part to the left of the window. All x-values are relative to the
2543 start of this total display area. */
2544 if (base_face_id
!= DEFAULT_FACE_ID
)
2546 /* Mode lines, menu bar in terminal frames. */
2547 it
->first_visible_x
= 0;
2548 it
->last_visible_x
= WINDOW_TOTAL_WIDTH (w
);
2553 = XFASTINT (it
->w
->hscroll
) * FRAME_COLUMN_WIDTH (it
->f
);
2554 it
->last_visible_x
= (it
->first_visible_x
2555 + window_box_width (w
, TEXT_AREA
));
2557 /* If we truncate lines, leave room for the truncator glyph(s) at
2558 the right margin. Otherwise, leave room for the continuation
2559 glyph(s). Truncation and continuation glyphs are not inserted
2560 for window-based redisplay. */
2561 if (!FRAME_WINDOW_P (it
->f
))
2563 if (it
->line_wrap
== TRUNCATE
)
2564 it
->last_visible_x
-= it
->truncation_pixel_width
;
2566 it
->last_visible_x
-= it
->continuation_pixel_width
;
2569 it
->header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
2570 it
->current_y
= WINDOW_HEADER_LINE_HEIGHT (w
) + w
->vscroll
;
2573 /* Leave room for a border glyph. */
2574 if (!FRAME_WINDOW_P (it
->f
)
2575 && !WINDOW_RIGHTMOST_P (it
->w
))
2576 it
->last_visible_x
-= 1;
2578 it
->last_visible_y
= window_text_bottom_y (w
);
2580 /* For mode lines and alike, arrange for the first glyph having a
2581 left box line if the face specifies a box. */
2582 if (base_face_id
!= DEFAULT_FACE_ID
)
2586 it
->face_id
= remapped_base_face_id
;
2588 /* If we have a boxed mode line, make the first character appear
2589 with a left box line. */
2590 face
= FACE_FROM_ID (it
->f
, remapped_base_face_id
);
2591 if (face
->box
!= FACE_NO_BOX
)
2592 it
->start_of_box_run_p
= 1;
2595 /* If a buffer position was specified, set the iterator there,
2596 getting overlays and face properties from that position. */
2597 if (charpos
>= BUF_BEG (current_buffer
))
2599 it
->end_charpos
= ZV
;
2601 IT_CHARPOS (*it
) = charpos
;
2603 /* Compute byte position if not specified. */
2604 if (bytepos
< charpos
)
2605 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (charpos
);
2607 IT_BYTEPOS (*it
) = bytepos
;
2609 it
->start
= it
->current
;
2610 /* Do we need to reorder bidirectional text? Not if this is a
2611 unibyte buffer: by definition, none of the single-byte
2612 characters are strong R2L, so no reordering is needed. And
2613 bidi.c doesn't support unibyte buffers anyway. */
2615 !NILP (BVAR (current_buffer
, bidi_display_reordering
))
2618 /* If we are to reorder bidirectional text, init the bidi
2622 /* Note the paragraph direction that this buffer wants to
2624 if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2626 it
->paragraph_embedding
= L2R
;
2627 else if (EQ (BVAR (current_buffer
, bidi_paragraph_direction
),
2629 it
->paragraph_embedding
= R2L
;
2631 it
->paragraph_embedding
= NEUTRAL_DIR
;
2632 bidi_unshelve_cache (NULL
);
2633 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
2637 /* Compute faces etc. */
2638 reseat (it
, it
->current
.pos
, 1);
2645 /* Initialize IT for the display of window W with window start POS. */
2648 start_display (struct it
*it
, struct window
*w
, struct text_pos pos
)
2650 struct glyph_row
*row
;
2651 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
2653 row
= w
->desired_matrix
->rows
+ first_vpos
;
2654 init_iterator (it
, w
, CHARPOS (pos
), BYTEPOS (pos
), row
, DEFAULT_FACE_ID
);
2655 it
->first_vpos
= first_vpos
;
2657 /* Don't reseat to previous visible line start if current start
2658 position is in a string or image. */
2659 if (it
->method
== GET_FROM_BUFFER
&& it
->line_wrap
!= TRUNCATE
)
2661 int start_at_line_beg_p
;
2662 int first_y
= it
->current_y
;
2664 /* If window start is not at a line start, skip forward to POS to
2665 get the correct continuation lines width. */
2666 start_at_line_beg_p
= (CHARPOS (pos
) == BEGV
2667 || FETCH_BYTE (BYTEPOS (pos
) - 1) == '\n');
2668 if (!start_at_line_beg_p
)
2672 reseat_at_previous_visible_line_start (it
);
2673 move_it_to (it
, CHARPOS (pos
), -1, -1, -1, MOVE_TO_POS
);
2675 new_x
= it
->current_x
+ it
->pixel_width
;
2677 /* If lines are continued, this line may end in the middle
2678 of a multi-glyph character (e.g. a control character
2679 displayed as \003, or in the middle of an overlay
2680 string). In this case move_it_to above will not have
2681 taken us to the start of the continuation line but to the
2682 end of the continued line. */
2683 if (it
->current_x
> 0
2684 && it
->line_wrap
!= TRUNCATE
/* Lines are continued. */
2685 && (/* And glyph doesn't fit on the line. */
2686 new_x
> it
->last_visible_x
2687 /* Or it fits exactly and we're on a window
2689 || (new_x
== it
->last_visible_x
2690 && FRAME_WINDOW_P (it
->f
))))
2692 if (it
->current
.dpvec_index
>= 0
2693 || it
->current
.overlay_string_index
>= 0)
2695 set_iterator_to_next (it
, 1);
2696 move_it_in_display_line_to (it
, -1, -1, 0);
2699 it
->continuation_lines_width
+= it
->current_x
;
2702 /* We're starting a new display line, not affected by the
2703 height of the continued line, so clear the appropriate
2704 fields in the iterator structure. */
2705 it
->max_ascent
= it
->max_descent
= 0;
2706 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
2708 it
->current_y
= first_y
;
2710 it
->current_x
= it
->hpos
= 0;
2716 /* Return 1 if POS is a position in ellipses displayed for invisible
2717 text. W is the window we display, for text property lookup. */
2720 in_ellipses_for_invisible_text_p (struct display_pos
*pos
, struct window
*w
)
2722 Lisp_Object prop
, window
;
2724 EMACS_INT charpos
= CHARPOS (pos
->pos
);
2726 /* If POS specifies a position in a display vector, this might
2727 be for an ellipsis displayed for invisible text. We won't
2728 get the iterator set up for delivering that ellipsis unless
2729 we make sure that it gets aware of the invisible text. */
2730 if (pos
->dpvec_index
>= 0
2731 && pos
->overlay_string_index
< 0
2732 && CHARPOS (pos
->string_pos
) < 0
2734 && (XSETWINDOW (window
, w
),
2735 prop
= Fget_char_property (make_number (charpos
),
2736 Qinvisible
, window
),
2737 !TEXT_PROP_MEANS_INVISIBLE (prop
)))
2739 prop
= Fget_char_property (make_number (charpos
- 1), Qinvisible
,
2741 ellipses_p
= 2 == TEXT_PROP_MEANS_INVISIBLE (prop
);
2748 /* Initialize IT for stepping through current_buffer in window W,
2749 starting at position POS that includes overlay string and display
2750 vector/ control character translation position information. Value
2751 is zero if there are overlay strings with newlines at POS. */
2754 init_from_display_pos (struct it
*it
, struct window
*w
, struct display_pos
*pos
)
2756 EMACS_INT charpos
= CHARPOS (pos
->pos
), bytepos
= BYTEPOS (pos
->pos
);
2757 int i
, overlay_strings_with_newlines
= 0;
2759 /* If POS specifies a position in a display vector, this might
2760 be for an ellipsis displayed for invisible text. We won't
2761 get the iterator set up for delivering that ellipsis unless
2762 we make sure that it gets aware of the invisible text. */
2763 if (in_ellipses_for_invisible_text_p (pos
, w
))
2769 /* Keep in mind: the call to reseat in init_iterator skips invisible
2770 text, so we might end up at a position different from POS. This
2771 is only a problem when POS is a row start after a newline and an
2772 overlay starts there with an after-string, and the overlay has an
2773 invisible property. Since we don't skip invisible text in
2774 display_line and elsewhere immediately after consuming the
2775 newline before the row start, such a POS will not be in a string,
2776 but the call to init_iterator below will move us to the
2778 init_iterator (it
, w
, charpos
, bytepos
, NULL
, DEFAULT_FACE_ID
);
2780 /* This only scans the current chunk -- it should scan all chunks.
2781 However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
2782 to 16 in 22.1 to make this a lesser problem. */
2783 for (i
= 0; i
< it
->n_overlay_strings
&& i
< OVERLAY_STRING_CHUNK_SIZE
; ++i
)
2785 const char *s
= SSDATA (it
->overlay_strings
[i
]);
2786 const char *e
= s
+ SBYTES (it
->overlay_strings
[i
]);
2788 while (s
< e
&& *s
!= '\n')
2793 overlay_strings_with_newlines
= 1;
2798 /* If position is within an overlay string, set up IT to the right
2800 if (pos
->overlay_string_index
>= 0)
2804 /* If the first overlay string happens to have a `display'
2805 property for an image, the iterator will be set up for that
2806 image, and we have to undo that setup first before we can
2807 correct the overlay string index. */
2808 if (it
->method
== GET_FROM_IMAGE
)
2811 /* We already have the first chunk of overlay strings in
2812 IT->overlay_strings. Load more until the one for
2813 pos->overlay_string_index is in IT->overlay_strings. */
2814 if (pos
->overlay_string_index
>= OVERLAY_STRING_CHUNK_SIZE
)
2816 int n
= pos
->overlay_string_index
/ OVERLAY_STRING_CHUNK_SIZE
;
2817 it
->current
.overlay_string_index
= 0;
2820 load_overlay_strings (it
, 0);
2821 it
->current
.overlay_string_index
+= OVERLAY_STRING_CHUNK_SIZE
;
2825 it
->current
.overlay_string_index
= pos
->overlay_string_index
;
2826 relative_index
= (it
->current
.overlay_string_index
2827 % OVERLAY_STRING_CHUNK_SIZE
);
2828 it
->string
= it
->overlay_strings
[relative_index
];
2829 xassert (STRINGP (it
->string
));
2830 it
->current
.string_pos
= pos
->string_pos
;
2831 it
->method
= GET_FROM_STRING
;
2834 if (CHARPOS (pos
->string_pos
) >= 0)
2836 /* Recorded position is not in an overlay string, but in another
2837 string. This can only be a string from a `display' property.
2838 IT should already be filled with that string. */
2839 it
->current
.string_pos
= pos
->string_pos
;
2840 xassert (STRINGP (it
->string
));
2843 /* Restore position in display vector translations, control
2844 character translations or ellipses. */
2845 if (pos
->dpvec_index
>= 0)
2847 if (it
->dpvec
== NULL
)
2848 get_next_display_element (it
);
2849 xassert (it
->dpvec
&& it
->current
.dpvec_index
== 0);
2850 it
->current
.dpvec_index
= pos
->dpvec_index
;
2854 return !overlay_strings_with_newlines
;
2858 /* Initialize IT for stepping through current_buffer in window W
2859 starting at ROW->start. */
2862 init_to_row_start (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
2864 init_from_display_pos (it
, w
, &row
->start
);
2865 it
->start
= row
->start
;
2866 it
->continuation_lines_width
= row
->continuation_lines_width
;
2871 /* Initialize IT for stepping through current_buffer in window W
2872 starting in the line following ROW, i.e. starting at ROW->end.
2873 Value is zero if there are overlay strings with newlines at ROW's
2877 init_to_row_end (struct it
*it
, struct window
*w
, struct glyph_row
*row
)
2881 if (init_from_display_pos (it
, w
, &row
->end
))
2883 if (row
->continued_p
)
2884 it
->continuation_lines_width
2885 = row
->continuation_lines_width
+ row
->pixel_width
;
2896 /***********************************************************************
2898 ***********************************************************************/
2900 /* Called when IT reaches IT->stop_charpos. Handle text property and
2901 overlay changes. Set IT->stop_charpos to the next position where
2905 handle_stop (struct it
*it
)
2907 enum prop_handled handled
;
2908 int handle_overlay_change_p
;
2912 it
->current
.dpvec_index
= -1;
2913 handle_overlay_change_p
= !it
->ignore_overlay_strings_at_pos_p
;
2914 it
->ignore_overlay_strings_at_pos_p
= 0;
2917 /* Use face of preceding text for ellipsis (if invisible) */
2918 if (it
->selective_display_ellipsis_p
)
2919 it
->saved_face_id
= it
->face_id
;
2923 handled
= HANDLED_NORMALLY
;
2925 /* Call text property handlers. */
2926 for (p
= it_props
; p
->handler
; ++p
)
2928 handled
= p
->handler (it
);
2930 if (handled
== HANDLED_RECOMPUTE_PROPS
)
2932 else if (handled
== HANDLED_RETURN
)
2934 /* We still want to show before and after strings from
2935 overlays even if the actual buffer text is replaced. */
2936 if (!handle_overlay_change_p
2938 || !get_overlay_strings_1 (it
, 0, 0))
2941 setup_for_ellipsis (it
, 0);
2942 /* When handling a display spec, we might load an
2943 empty string. In that case, discard it here. We
2944 used to discard it in handle_single_display_spec,
2945 but that causes get_overlay_strings_1, above, to
2946 ignore overlay strings that we must check. */
2947 if (STRINGP (it
->string
) && !SCHARS (it
->string
))
2951 else if (STRINGP (it
->string
) && !SCHARS (it
->string
))
2955 it
->ignore_overlay_strings_at_pos_p
= 1;
2956 it
->string_from_display_prop_p
= 0;
2957 it
->from_disp_prop_p
= 0;
2958 handle_overlay_change_p
= 0;
2960 handled
= HANDLED_RECOMPUTE_PROPS
;
2963 else if (handled
== HANDLED_OVERLAY_STRING_CONSUMED
)
2964 handle_overlay_change_p
= 0;
2967 if (handled
!= HANDLED_RECOMPUTE_PROPS
)
2969 /* Don't check for overlay strings below when set to deliver
2970 characters from a display vector. */
2971 if (it
->method
== GET_FROM_DISPLAY_VECTOR
)
2972 handle_overlay_change_p
= 0;
2974 /* Handle overlay changes.
2975 This sets HANDLED to HANDLED_RECOMPUTE_PROPS
2976 if it finds overlays. */
2977 if (handle_overlay_change_p
)
2978 handled
= handle_overlay_change (it
);
2983 setup_for_ellipsis (it
, 0);
2987 while (handled
== HANDLED_RECOMPUTE_PROPS
);
2989 /* Determine where to stop next. */
2990 if (handled
== HANDLED_NORMALLY
)
2991 compute_stop_pos (it
);
2995 /* Compute IT->stop_charpos from text property and overlay change
2996 information for IT's current position. */
2999 compute_stop_pos (struct it
*it
)
3001 register INTERVAL iv
, next_iv
;
3002 Lisp_Object object
, limit
, position
;
3003 EMACS_INT charpos
, bytepos
;
3005 /* If nowhere else, stop at the end. */
3006 it
->stop_charpos
= it
->end_charpos
;
3008 if (STRINGP (it
->string
))
3010 /* Strings are usually short, so don't limit the search for
3012 object
= it
->string
;
3014 charpos
= IT_STRING_CHARPOS (*it
);
3015 bytepos
= IT_STRING_BYTEPOS (*it
);
3021 /* If next overlay change is in front of the current stop pos
3022 (which is IT->end_charpos), stop there. Note: value of
3023 next_overlay_change is point-max if no overlay change
3025 charpos
= IT_CHARPOS (*it
);
3026 bytepos
= IT_BYTEPOS (*it
);
3027 pos
= next_overlay_change (charpos
);
3028 if (pos
< it
->stop_charpos
)
3029 it
->stop_charpos
= pos
;
3031 /* If showing the region, we have to stop at the region
3032 start or end because the face might change there. */
3033 if (it
->region_beg_charpos
> 0)
3035 if (IT_CHARPOS (*it
) < it
->region_beg_charpos
)
3036 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_beg_charpos
);
3037 else if (IT_CHARPOS (*it
) < it
->region_end_charpos
)
3038 it
->stop_charpos
= min (it
->stop_charpos
, it
->region_end_charpos
);
3041 /* Set up variables for computing the stop position from text
3042 property changes. */
3043 XSETBUFFER (object
, current_buffer
);
3044 limit
= make_number (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
);
3047 /* Get the interval containing IT's position. Value is a null
3048 interval if there isn't such an interval. */
3049 position
= make_number (charpos
);
3050 iv
= validate_interval_range (object
, &position
, &position
, 0);
3051 if (!NULL_INTERVAL_P (iv
))
3053 Lisp_Object values_here
[LAST_PROP_IDX
];
3056 /* Get properties here. */
3057 for (p
= it_props
; p
->handler
; ++p
)
3058 values_here
[p
->idx
] = textget (iv
->plist
, *p
->name
);
3060 /* Look for an interval following iv that has different
3062 for (next_iv
= next_interval (iv
);
3063 (!NULL_INTERVAL_P (next_iv
)
3065 || XFASTINT (limit
) > next_iv
->position
));
3066 next_iv
= next_interval (next_iv
))
3068 for (p
= it_props
; p
->handler
; ++p
)
3070 Lisp_Object new_value
;
3072 new_value
= textget (next_iv
->plist
, *p
->name
);
3073 if (!EQ (values_here
[p
->idx
], new_value
))
3081 if (!NULL_INTERVAL_P (next_iv
))
3083 if (INTEGERP (limit
)
3084 && next_iv
->position
>= XFASTINT (limit
))
3085 /* No text property change up to limit. */
3086 it
->stop_charpos
= min (XFASTINT (limit
), it
->stop_charpos
);
3088 /* Text properties change in next_iv. */
3089 it
->stop_charpos
= min (it
->stop_charpos
, next_iv
->position
);
3093 if (it
->cmp_it
.id
< 0)
3095 EMACS_INT stoppos
= it
->end_charpos
;
3097 if (it
->bidi_p
&& it
->bidi_it
.scan_dir
< 0)
3099 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
,
3100 stoppos
, it
->string
);
3103 xassert (STRINGP (it
->string
)
3104 || (it
->stop_charpos
>= BEGV
3105 && it
->stop_charpos
>= IT_CHARPOS (*it
)));
3109 /* Return the position of the next overlay change after POS in
3110 current_buffer. Value is point-max if no overlay change
3111 follows. This is like `next-overlay-change' but doesn't use
3115 next_overlay_change (EMACS_INT pos
)
3119 Lisp_Object
*overlays
;
3122 /* Get all overlays at the given position. */
3123 GET_OVERLAYS_AT (pos
, overlays
, noverlays
, &endpos
, 1);
3125 /* If any of these overlays ends before endpos,
3126 use its ending point instead. */
3127 for (i
= 0; i
< noverlays
; ++i
)
3132 oend
= OVERLAY_END (overlays
[i
]);
3133 oendpos
= OVERLAY_POSITION (oend
);
3134 endpos
= min (endpos
, oendpos
);
3140 /* Record one cached display string position found recently by
3141 compute_display_string_pos. */
3142 static EMACS_INT cached_disp_pos
;
3143 static EMACS_INT cached_prev_pos
= -1;
3144 static struct buffer
*cached_disp_buffer
;
3145 static int cached_disp_modiff
;
3146 static int cached_disp_overlay_modiff
;
3148 static int ignore_display_strings
;
3150 /* Return the character position of a display string at or after
3151 position specified by POSITION. If no display string exists at or
3152 after POSITION, return ZV. A display string is either an overlay
3153 with `display' property whose value is a string, or a `display'
3154 text property whose value is a string. STRING is data about the
3155 string to iterate; if STRING->lstring is nil, we are iterating a
3156 buffer. FRAME_WINDOW_P is non-zero when we are displaying a window
3159 compute_display_string_pos (struct text_pos
*position
,
3160 struct bidi_string_data
*string
, int frame_window_p
)
3162 /* OBJECT = nil means current buffer. */
3163 Lisp_Object object
=
3164 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3165 Lisp_Object pos
, spec
;
3166 int string_p
= (string
&& (STRINGP (string
->lstring
) || string
->s
));
3167 EMACS_INT eob
= string_p
? string
->schars
: ZV
;
3168 EMACS_INT begb
= string_p
? 0 : BEGV
;
3169 EMACS_INT bufpos
, charpos
= CHARPOS (*position
);
3170 struct text_pos tpos
;
3174 /* We don't support display properties whose values are strings
3175 that have display string properties. */
3176 || string
->from_disp_str
3177 /* C strings cannot have display properties. */
3178 || (string
->s
&& !STRINGP (object
))
3179 || ignore_display_strings
)
3182 /* Check the cached values. */
3183 if (!STRINGP (object
))
3188 b
= XBUFFER (object
);
3189 if (b
== cached_disp_buffer
3190 && BUF_MODIFF (b
) == cached_disp_modiff
3191 && BUF_OVERLAY_MODIFF (b
) == cached_disp_overlay_modiff
)
3193 if (cached_prev_pos
>= 0
3194 && cached_prev_pos
< charpos
&& charpos
<= cached_disp_pos
)
3195 return cached_disp_pos
;
3196 /* Handle overstepping either end of the known interval. */
3197 if (charpos
> cached_disp_pos
)
3198 cached_prev_pos
= cached_disp_pos
;
3199 else /* charpos <= cached_prev_pos */
3200 cached_prev_pos
= max (charpos
- 1, 0);
3203 /* Record new values in the cache. */
3204 if (b
!= cached_disp_buffer
)
3206 cached_disp_buffer
= b
;
3207 cached_prev_pos
= max (charpos
- 1, 0);
3209 cached_disp_modiff
= BUF_MODIFF (b
);
3210 cached_disp_overlay_modiff
= BUF_OVERLAY_MODIFF (b
);
3213 /* If the character at CHARPOS is where the display string begins,
3215 pos
= make_number (charpos
);
3216 if (STRINGP (object
))
3217 bufpos
= string
->bufpos
;
3221 if (!NILP (spec
= Fget_char_property (pos
, Qdisplay
, object
))
3223 || !EQ (Fget_char_property (make_number (charpos
- 1), Qdisplay
,
3226 && handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
, bufpos
,
3229 if (!STRINGP (object
))
3230 cached_disp_pos
= charpos
;
3234 /* Look forward for the first character with a `display' property
3235 that will replace the underlying text when displayed. */
3237 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3238 CHARPOS (tpos
) = XFASTINT (pos
);
3239 if (STRINGP (object
))
3240 BYTEPOS (tpos
) = string_char_to_byte (object
, CHARPOS (tpos
));
3242 BYTEPOS (tpos
) = CHAR_TO_BYTE (CHARPOS (tpos
));
3243 if (CHARPOS (tpos
) >= eob
)
3245 spec
= Fget_char_property (pos
, Qdisplay
, object
);
3246 if (!STRINGP (object
))
3247 bufpos
= CHARPOS (tpos
);
3248 } while (NILP (spec
)
3249 || !handle_display_spec (NULL
, spec
, object
, Qnil
, &tpos
, bufpos
,
3252 if (!STRINGP (object
))
3253 cached_disp_pos
= CHARPOS (tpos
);
3254 return CHARPOS (tpos
);
3257 /* Return the character position of the end of the display string that
3258 started at CHARPOS. A display string is either an overlay with
3259 `display' property whose value is a string or a `display' text
3260 property whose value is a string. */
3262 compute_display_string_end (EMACS_INT charpos
, struct bidi_string_data
*string
)
3264 /* OBJECT = nil means current buffer. */
3265 Lisp_Object object
=
3266 (string
&& STRINGP (string
->lstring
)) ? string
->lstring
: Qnil
;
3267 Lisp_Object pos
= make_number (charpos
);
3269 (STRINGP (object
) || (string
&& string
->s
)) ? string
->schars
: ZV
;
3271 if (charpos
>= eob
|| (string
->s
&& !STRINGP (object
)))
3274 if (NILP (Fget_char_property (pos
, Qdisplay
, object
)))
3277 /* Look forward for the first character where the `display' property
3279 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, object
, Qnil
);
3281 return XFASTINT (pos
);
3286 /***********************************************************************
3288 ***********************************************************************/
3290 /* Handle changes in the `fontified' property of the current buffer by
3291 calling hook functions from Qfontification_functions to fontify
3294 static enum prop_handled
3295 handle_fontified_prop (struct it
*it
)
3297 Lisp_Object prop
, pos
;
3298 enum prop_handled handled
= HANDLED_NORMALLY
;
3300 if (!NILP (Vmemory_full
))
3303 /* Get the value of the `fontified' property at IT's current buffer
3304 position. (The `fontified' property doesn't have a special
3305 meaning in strings.) If the value is nil, call functions from
3306 Qfontification_functions. */
3307 if (!STRINGP (it
->string
)
3309 && !NILP (Vfontification_functions
)
3310 && !NILP (Vrun_hooks
)
3311 && (pos
= make_number (IT_CHARPOS (*it
)),
3312 prop
= Fget_char_property (pos
, Qfontified
, Qnil
),
3313 /* Ignore the special cased nil value always present at EOB since
3314 no amount of fontifying will be able to change it. */
3315 NILP (prop
) && IT_CHARPOS (*it
) < Z
))
3317 int count
= SPECPDL_INDEX ();
3319 struct buffer
*obuf
= current_buffer
;
3320 int begv
= BEGV
, zv
= ZV
;
3321 int old_clip_changed
= current_buffer
->clip_changed
;
3323 val
= Vfontification_functions
;
3324 specbind (Qfontification_functions
, Qnil
);
3326 xassert (it
->end_charpos
== ZV
);
3328 if (!CONSP (val
) || EQ (XCAR (val
), Qlambda
))
3329 safe_call1 (val
, pos
);
3332 Lisp_Object fns
, fn
;
3333 struct gcpro gcpro1
, gcpro2
;
3338 for (; CONSP (val
); val
= XCDR (val
))
3344 /* A value of t indicates this hook has a local
3345 binding; it means to run the global binding too.
3346 In a global value, t should not occur. If it
3347 does, we must ignore it to avoid an endless
3349 for (fns
= Fdefault_value (Qfontification_functions
);
3355 safe_call1 (fn
, pos
);
3359 safe_call1 (fn
, pos
);
3365 unbind_to (count
, Qnil
);
3367 /* Fontification functions routinely call `save-restriction'.
3368 Normally, this tags clip_changed, which can confuse redisplay
3369 (see discussion in Bug#6671). Since we don't perform any
3370 special handling of fontification changes in the case where
3371 `save-restriction' isn't called, there's no point doing so in
3372 this case either. So, if the buffer's restrictions are
3373 actually left unchanged, reset clip_changed. */
3374 if (obuf
== current_buffer
)
3376 if (begv
== BEGV
&& zv
== ZV
)
3377 current_buffer
->clip_changed
= old_clip_changed
;
3379 /* There isn't much we can reasonably do to protect against
3380 misbehaving fontification, but here's a fig leaf. */
3381 else if (!NILP (BVAR (obuf
, name
)))
3382 set_buffer_internal_1 (obuf
);
3384 /* The fontification code may have added/removed text.
3385 It could do even a lot worse, but let's at least protect against
3386 the most obvious case where only the text past `pos' gets changed',
3387 as is/was done in grep.el where some escapes sequences are turned
3388 into face properties (bug#7876). */
3389 it
->end_charpos
= ZV
;
3391 /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
3392 something. This avoids an endless loop if they failed to
3393 fontify the text for which reason ever. */
3394 if (!NILP (Fget_char_property (pos
, Qfontified
, Qnil
)))
3395 handled
= HANDLED_RECOMPUTE_PROPS
;
3403 /***********************************************************************
3405 ***********************************************************************/
3407 /* Set up iterator IT from face properties at its current position.
3408 Called from handle_stop. */
3410 static enum prop_handled
3411 handle_face_prop (struct it
*it
)
3414 EMACS_INT next_stop
;
3416 if (!STRINGP (it
->string
))
3419 = face_at_buffer_position (it
->w
,
3421 it
->region_beg_charpos
,
3422 it
->region_end_charpos
,
3425 + TEXT_PROP_DISTANCE_LIMIT
),
3426 0, it
->base_face_id
);
3428 /* Is this a start of a run of characters with box face?
3429 Caveat: this can be called for a freshly initialized
3430 iterator; face_id is -1 in this case. We know that the new
3431 face will not change until limit, i.e. if the new face has a
3432 box, all characters up to limit will have one. But, as
3433 usual, we don't know whether limit is really the end. */
3434 if (new_face_id
!= it
->face_id
)
3436 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3438 /* If new face has a box but old face has not, this is
3439 the start of a run of characters with box, i.e. it has
3440 a shadow on the left side. The value of face_id of the
3441 iterator will be -1 if this is the initial call that gets
3442 the face. In this case, we have to look in front of IT's
3443 position and see whether there is a face != new_face_id. */
3444 it
->start_of_box_run_p
3445 = (new_face
->box
!= FACE_NO_BOX
3446 && (it
->face_id
>= 0
3447 || IT_CHARPOS (*it
) == BEG
3448 || new_face_id
!= face_before_it_pos (it
)));
3449 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3457 Lisp_Object from_overlay
3458 = (it
->current
.overlay_string_index
>= 0
3459 ? it
->string_overlays
[it
->current
.overlay_string_index
]
3462 /* See if we got to this string directly or indirectly from
3463 an overlay property. That includes the before-string or
3464 after-string of an overlay, strings in display properties
3465 provided by an overlay, their text properties, etc.
3467 FROM_OVERLAY is the overlay that brought us here, or nil if none. */
3468 if (! NILP (from_overlay
))
3469 for (i
= it
->sp
- 1; i
>= 0; i
--)
3471 if (it
->stack
[i
].current
.overlay_string_index
>= 0)
3473 = it
->string_overlays
[it
->stack
[i
].current
.overlay_string_index
];
3474 else if (! NILP (it
->stack
[i
].from_overlay
))
3475 from_overlay
= it
->stack
[i
].from_overlay
;
3477 if (!NILP (from_overlay
))
3481 if (! NILP (from_overlay
))
3483 bufpos
= IT_CHARPOS (*it
);
3484 /* For a string from an overlay, the base face depends
3485 only on text properties and ignores overlays. */
3487 = face_for_overlay_string (it
->w
,
3489 it
->region_beg_charpos
,
3490 it
->region_end_charpos
,
3493 + TEXT_PROP_DISTANCE_LIMIT
),
3501 /* For strings from a `display' property, use the face at
3502 IT's current buffer position as the base face to merge
3503 with, so that overlay strings appear in the same face as
3504 surrounding text, unless they specify their own
3506 base_face_id
= underlying_face_id (it
);
3509 new_face_id
= face_at_string_position (it
->w
,
3511 IT_STRING_CHARPOS (*it
),
3513 it
->region_beg_charpos
,
3514 it
->region_end_charpos
,
3518 /* Is this a start of a run of characters with box? Caveat:
3519 this can be called for a freshly allocated iterator; face_id
3520 is -1 is this case. We know that the new face will not
3521 change until the next check pos, i.e. if the new face has a
3522 box, all characters up to that position will have a
3523 box. But, as usual, we don't know whether that position
3524 is really the end. */
3525 if (new_face_id
!= it
->face_id
)
3527 struct face
*new_face
= FACE_FROM_ID (it
->f
, new_face_id
);
3528 struct face
*old_face
= FACE_FROM_ID (it
->f
, it
->face_id
);
3530 /* If new face has a box but old face hasn't, this is the
3531 start of a run of characters with box, i.e. it has a
3532 shadow on the left side. */
3533 it
->start_of_box_run_p
3534 = new_face
->box
&& (old_face
== NULL
|| !old_face
->box
);
3535 it
->face_box_p
= new_face
->box
!= FACE_NO_BOX
;
3539 it
->face_id
= new_face_id
;
3540 return HANDLED_NORMALLY
;
3544 /* Return the ID of the face ``underlying'' IT's current position,
3545 which is in a string. If the iterator is associated with a
3546 buffer, return the face at IT's current buffer position.
3547 Otherwise, use the iterator's base_face_id. */
3550 underlying_face_id (struct it
*it
)
3552 int face_id
= it
->base_face_id
, i
;
3554 xassert (STRINGP (it
->string
));
3556 for (i
= it
->sp
- 1; i
>= 0; --i
)
3557 if (NILP (it
->stack
[i
].string
))
3558 face_id
= it
->stack
[i
].face_id
;
3564 /* Compute the face one character before or after the current position
3565 of IT, in the visual order. BEFORE_P non-zero means get the face
3566 in front (to the left in L2R paragraphs, to the right in R2L
3567 paragraphs) of IT's screen position. Value is the ID of the face. */
3570 face_before_or_after_it_pos (struct it
*it
, int before_p
)
3573 EMACS_INT next_check_charpos
;
3575 void *it_copy_data
= NULL
;
3577 xassert (it
->s
== NULL
);
3579 if (STRINGP (it
->string
))
3581 EMACS_INT bufpos
, charpos
;
3584 /* No face change past the end of the string (for the case
3585 we are padding with spaces). No face change before the
3587 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
)
3588 || (IT_STRING_CHARPOS (*it
) == 0 && before_p
))
3593 /* Set charpos to the position before or after IT's current
3594 position, in the logical order, which in the non-bidi
3595 case is the same as the visual order. */
3597 charpos
= IT_STRING_CHARPOS (*it
) - 1;
3598 else if (it
->what
== IT_COMPOSITION
)
3599 /* For composition, we must check the character after the
3601 charpos
= IT_STRING_CHARPOS (*it
) + it
->cmp_it
.nchars
;
3603 charpos
= IT_STRING_CHARPOS (*it
) + 1;
3609 /* With bidi iteration, the character before the current
3610 in the visual order cannot be found by simple
3611 iteration, because "reverse" reordering is not
3612 supported. Instead, we need to use the move_it_*
3613 family of functions. */
3614 /* Ignore face changes before the first visible
3615 character on this display line. */
3616 if (it
->current_x
<= it
->first_visible_x
)
3618 SAVE_IT (it_copy
, *it
, it_copy_data
);
3619 /* Implementation note: Since move_it_in_display_line
3620 works in the iterator geometry, and thinks the first
3621 character is always the leftmost, even in R2L lines,
3622 we don't need to distinguish between the R2L and L2R
3624 move_it_in_display_line (&it_copy
, SCHARS (it_copy
.string
),
3625 it_copy
.current_x
- 1, MOVE_TO_X
);
3626 charpos
= IT_STRING_CHARPOS (it_copy
);
3627 RESTORE_IT (it
, it
, it_copy_data
);
3631 /* Set charpos to the string position of the character
3632 that comes after IT's current position in the visual
3634 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
3638 bidi_move_to_visually_next (&it_copy
.bidi_it
);
3640 charpos
= it_copy
.bidi_it
.charpos
;
3643 xassert (0 <= charpos
&& charpos
<= SCHARS (it
->string
));
3645 if (it
->current
.overlay_string_index
>= 0)
3646 bufpos
= IT_CHARPOS (*it
);
3650 base_face_id
= underlying_face_id (it
);
3652 /* Get the face for ASCII, or unibyte. */
3653 face_id
= face_at_string_position (it
->w
,
3657 it
->region_beg_charpos
,
3658 it
->region_end_charpos
,
3659 &next_check_charpos
,
3662 /* Correct the face for charsets different from ASCII. Do it
3663 for the multibyte case only. The face returned above is
3664 suitable for unibyte text if IT->string is unibyte. */
3665 if (STRING_MULTIBYTE (it
->string
))
3667 struct text_pos pos1
= string_pos (charpos
, it
->string
);
3668 const unsigned char *p
= SDATA (it
->string
) + BYTEPOS (pos1
);
3670 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3672 c
= string_char_and_length (p
, &len
);
3673 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, charpos
, it
->string
);
3678 struct text_pos pos
;
3680 if ((IT_CHARPOS (*it
) >= ZV
&& !before_p
)
3681 || (IT_CHARPOS (*it
) <= BEGV
&& before_p
))
3684 limit
= IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
;
3685 pos
= it
->current
.pos
;
3690 DEC_TEXT_POS (pos
, it
->multibyte_p
);
3693 if (it
->what
== IT_COMPOSITION
)
3695 /* For composition, we must check the position after
3697 pos
.charpos
+= it
->cmp_it
.nchars
;
3698 pos
.bytepos
+= it
->len
;
3701 INC_TEXT_POS (pos
, it
->multibyte_p
);
3708 /* With bidi iteration, the character before the current
3709 in the visual order cannot be found by simple
3710 iteration, because "reverse" reordering is not
3711 supported. Instead, we need to use the move_it_*
3712 family of functions. */
3713 /* Ignore face changes before the first visible
3714 character on this display line. */
3715 if (it
->current_x
<= it
->first_visible_x
)
3717 SAVE_IT (it_copy
, *it
, it_copy_data
);
3718 /* Implementation note: Since move_it_in_display_line
3719 works in the iterator geometry, and thinks the first
3720 character is always the leftmost, even in R2L lines,
3721 we don't need to distinguish between the R2L and L2R
3723 move_it_in_display_line (&it_copy
, ZV
,
3724 it_copy
.current_x
- 1, MOVE_TO_X
);
3725 pos
= it_copy
.current
.pos
;
3726 RESTORE_IT (it
, it
, it_copy_data
);
3730 /* Set charpos to the buffer position of the character
3731 that comes after IT's current position in the visual
3733 int n
= (it
->what
== IT_COMPOSITION
? it
->cmp_it
.nchars
: 1);
3737 bidi_move_to_visually_next (&it_copy
.bidi_it
);
3740 it_copy
.bidi_it
.charpos
, it_copy
.bidi_it
.bytepos
);
3743 xassert (BEGV
<= CHARPOS (pos
) && CHARPOS (pos
) <= ZV
);
3745 /* Determine face for CHARSET_ASCII, or unibyte. */
3746 face_id
= face_at_buffer_position (it
->w
,
3748 it
->region_beg_charpos
,
3749 it
->region_end_charpos
,
3750 &next_check_charpos
,
3753 /* Correct the face for charsets different from ASCII. Do it
3754 for the multibyte case only. The face returned above is
3755 suitable for unibyte text if current_buffer is unibyte. */
3756 if (it
->multibyte_p
)
3758 int c
= FETCH_MULTIBYTE_CHAR (BYTEPOS (pos
));
3759 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
3760 face_id
= FACE_FOR_CHAR (it
->f
, face
, c
, CHARPOS (pos
), Qnil
);
3769 /***********************************************************************
3771 ***********************************************************************/
3773 /* Set up iterator IT from invisible properties at its current
3774 position. Called from handle_stop. */
3776 static enum prop_handled
3777 handle_invisible_prop (struct it
*it
)
3779 enum prop_handled handled
= HANDLED_NORMALLY
;
3781 if (STRINGP (it
->string
))
3783 Lisp_Object prop
, end_charpos
, limit
, charpos
;
3785 /* Get the value of the invisible text property at the
3786 current position. Value will be nil if there is no such
3788 charpos
= make_number (IT_STRING_CHARPOS (*it
));
3789 prop
= Fget_text_property (charpos
, Qinvisible
, it
->string
);
3792 && IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
3796 handled
= HANDLED_RECOMPUTE_PROPS
;
3798 /* Get the position at which the next change of the
3799 invisible text property can be found in IT->string.
3800 Value will be nil if the property value is the same for
3801 all the rest of IT->string. */
3802 XSETINT (limit
, SCHARS (it
->string
));
3803 end_charpos
= Fnext_single_property_change (charpos
, Qinvisible
,
3806 /* Text at current position is invisible. The next
3807 change in the property is at position end_charpos.
3808 Move IT's current position to that position. */
3809 if (INTEGERP (end_charpos
)
3810 && (endpos
= XFASTINT (end_charpos
)) < XFASTINT (limit
))
3812 struct text_pos old
;
3815 old
= it
->current
.string_pos
;
3816 oldpos
= CHARPOS (old
);
3819 if (it
->bidi_it
.first_elt
3820 && it
->bidi_it
.charpos
< SCHARS (it
->string
))
3821 bidi_paragraph_init (it
->paragraph_embedding
,
3823 /* Bidi-iterate out of the invisible text. */
3826 bidi_move_to_visually_next (&it
->bidi_it
);
3828 while (oldpos
<= it
->bidi_it
.charpos
3829 && it
->bidi_it
.charpos
< endpos
);
3831 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
3832 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
3833 if (IT_CHARPOS (*it
) >= endpos
)
3834 it
->prev_stop
= endpos
;
3838 IT_STRING_CHARPOS (*it
) = XFASTINT (end_charpos
);
3839 compute_string_pos (&it
->current
.string_pos
, old
, it
->string
);
3844 /* The rest of the string is invisible. If this is an
3845 overlay string, proceed with the next overlay string
3846 or whatever comes and return a character from there. */
3847 if (it
->current
.overlay_string_index
>= 0)
3849 next_overlay_string (it
);
3850 /* Don't check for overlay strings when we just
3851 finished processing them. */
3852 handled
= HANDLED_OVERLAY_STRING_CONSUMED
;
3856 IT_STRING_CHARPOS (*it
) = SCHARS (it
->string
);
3857 IT_STRING_BYTEPOS (*it
) = SBYTES (it
->string
);
3865 EMACS_INT newpos
, next_stop
, start_charpos
, tem
;
3866 Lisp_Object pos
, prop
, overlay
;
3868 /* First of all, is there invisible text at this position? */
3869 tem
= start_charpos
= IT_CHARPOS (*it
);
3870 pos
= make_number (tem
);
3871 prop
= get_char_property_and_overlay (pos
, Qinvisible
, it
->window
,
3873 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3875 /* If we are on invisible text, skip over it. */
3876 if (invis_p
&& start_charpos
< it
->end_charpos
)
3878 /* Record whether we have to display an ellipsis for the
3880 int display_ellipsis_p
= invis_p
== 2;
3882 handled
= HANDLED_RECOMPUTE_PROPS
;
3884 /* Loop skipping over invisible text. The loop is left at
3885 ZV or with IT on the first char being visible again. */
3888 /* Try to skip some invisible text. Return value is the
3889 position reached which can be equal to where we start
3890 if there is nothing invisible there. This skips both
3891 over invisible text properties and overlays with
3892 invisible property. */
3893 newpos
= skip_invisible (tem
, &next_stop
, ZV
, it
->window
);
3895 /* If we skipped nothing at all we weren't at invisible
3896 text in the first place. If everything to the end of
3897 the buffer was skipped, end the loop. */
3898 if (newpos
== tem
|| newpos
>= ZV
)
3902 /* We skipped some characters but not necessarily
3903 all there are. Check if we ended up on visible
3904 text. Fget_char_property returns the property of
3905 the char before the given position, i.e. if we
3906 get invis_p = 0, this means that the char at
3907 newpos is visible. */
3908 pos
= make_number (newpos
);
3909 prop
= Fget_char_property (pos
, Qinvisible
, it
->window
);
3910 invis_p
= TEXT_PROP_MEANS_INVISIBLE (prop
);
3913 /* If we ended up on invisible text, proceed to
3914 skip starting with next_stop. */
3918 /* If there are adjacent invisible texts, don't lose the
3919 second one's ellipsis. */
3921 display_ellipsis_p
= 1;
3925 /* The position newpos is now either ZV or on visible text. */
3926 if (it
->bidi_p
&& newpos
< ZV
)
3928 /* With bidi iteration, the region of invisible text
3929 could start and/or end in the middle of a non-base
3930 embedding level. Therefore, we need to skip
3931 invisible text using the bidi iterator, starting at
3932 IT's current position, until we find ourselves
3933 outside the invisible text. Skipping invisible text
3934 _after_ bidi iteration avoids affecting the visual
3935 order of the displayed text when invisible properties
3936 are added or removed. */
3937 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< ZV
)
3939 /* If we were `reseat'ed to a new paragraph,
3940 determine the paragraph base direction. We need
3941 to do it now because next_element_from_buffer may
3942 not have a chance to do it, if we are going to
3943 skip any text at the beginning, which resets the
3945 bidi_paragraph_init (it
->paragraph_embedding
,
3950 bidi_move_to_visually_next (&it
->bidi_it
);
3952 while (it
->stop_charpos
<= it
->bidi_it
.charpos
3953 && it
->bidi_it
.charpos
< newpos
);
3954 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
3955 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
3956 /* If we overstepped NEWPOS, record its position in the
3957 iterator, so that we skip invisible text if later the
3958 bidi iteration lands us in the invisible region
3960 if (IT_CHARPOS (*it
) >= newpos
)
3961 it
->prev_stop
= newpos
;
3965 IT_CHARPOS (*it
) = newpos
;
3966 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (newpos
);
3969 /* If there are before-strings at the start of invisible
3970 text, and the text is invisible because of a text
3971 property, arrange to show before-strings because 20.x did
3972 it that way. (If the text is invisible because of an
3973 overlay property instead of a text property, this is
3974 already handled in the overlay code.) */
3976 && get_overlay_strings (it
, it
->stop_charpos
))
3978 handled
= HANDLED_RECOMPUTE_PROPS
;
3979 it
->stack
[it
->sp
- 1].display_ellipsis_p
= display_ellipsis_p
;
3981 else if (display_ellipsis_p
)
3983 /* Make sure that the glyphs of the ellipsis will get
3984 correct `charpos' values. If we would not update
3985 it->position here, the glyphs would belong to the
3986 last visible character _before_ the invisible
3987 text, which confuses `set_cursor_from_row'.
3989 We use the last invisible position instead of the
3990 first because this way the cursor is always drawn on
3991 the first "." of the ellipsis, whenever PT is inside
3992 the invisible text. Otherwise the cursor would be
3993 placed _after_ the ellipsis when the point is after the
3994 first invisible character. */
3995 if (!STRINGP (it
->object
))
3997 it
->position
.charpos
= newpos
- 1;
3998 it
->position
.bytepos
= CHAR_TO_BYTE (it
->position
.charpos
);
4001 /* Let the ellipsis display before
4002 considering any properties of the following char.
4003 Fixes jasonr@gnu.org 01 Oct 07 bug. */
4004 handled
= HANDLED_RETURN
;
4013 /* Make iterator IT return `...' next.
4014 Replaces LEN characters from buffer. */
4017 setup_for_ellipsis (struct it
*it
, int len
)
4019 /* Use the display table definition for `...'. Invalid glyphs
4020 will be handled by the method returning elements from dpvec. */
4021 if (it
->dp
&& VECTORP (DISP_INVIS_VECTOR (it
->dp
)))
4023 struct Lisp_Vector
*v
= XVECTOR (DISP_INVIS_VECTOR (it
->dp
));
4024 it
->dpvec
= v
->contents
;
4025 it
->dpend
= v
->contents
+ v
->header
.size
;
4029 /* Default `...'. */
4030 it
->dpvec
= default_invis_vector
;
4031 it
->dpend
= default_invis_vector
+ 3;
4034 it
->dpvec_char_len
= len
;
4035 it
->current
.dpvec_index
= 0;
4036 it
->dpvec_face_id
= -1;
4038 /* Remember the current face id in case glyphs specify faces.
4039 IT's face is restored in set_iterator_to_next.
4040 saved_face_id was set to preceding char's face in handle_stop. */
4041 if (it
->saved_face_id
< 0 || it
->saved_face_id
!= it
->face_id
)
4042 it
->saved_face_id
= it
->face_id
= DEFAULT_FACE_ID
;
4044 it
->method
= GET_FROM_DISPLAY_VECTOR
;
4050 /***********************************************************************
4052 ***********************************************************************/
4054 /* Set up iterator IT from `display' property at its current position.
4055 Called from handle_stop.
4056 We return HANDLED_RETURN if some part of the display property
4057 overrides the display of the buffer text itself.
4058 Otherwise we return HANDLED_NORMALLY. */
4060 static enum prop_handled
4061 handle_display_prop (struct it
*it
)
4063 Lisp_Object propval
, object
, overlay
;
4064 struct text_pos
*position
;
4066 /* Nonzero if some property replaces the display of the text itself. */
4067 int display_replaced_p
= 0;
4069 if (STRINGP (it
->string
))
4071 object
= it
->string
;
4072 position
= &it
->current
.string_pos
;
4073 bufpos
= CHARPOS (it
->current
.pos
);
4077 XSETWINDOW (object
, it
->w
);
4078 position
= &it
->current
.pos
;
4079 bufpos
= CHARPOS (*position
);
4082 /* Reset those iterator values set from display property values. */
4083 it
->slice
.x
= it
->slice
.y
= it
->slice
.width
= it
->slice
.height
= Qnil
;
4084 it
->space_width
= Qnil
;
4085 it
->font_height
= Qnil
;
4088 /* We don't support recursive `display' properties, i.e. string
4089 values that have a string `display' property, that have a string
4090 `display' property etc. */
4091 if (!it
->string_from_display_prop_p
)
4092 it
->area
= TEXT_AREA
;
4094 propval
= get_char_property_and_overlay (make_number (position
->charpos
),
4095 Qdisplay
, object
, &overlay
);
4097 return HANDLED_NORMALLY
;
4098 /* Now OVERLAY is the overlay that gave us this property, or nil
4099 if it was a text property. */
4101 if (!STRINGP (it
->string
))
4102 object
= it
->w
->buffer
;
4104 display_replaced_p
= handle_display_spec (it
, propval
, object
, overlay
,
4106 FRAME_WINDOW_P (it
->f
));
4108 return display_replaced_p
? HANDLED_RETURN
: HANDLED_NORMALLY
;
4111 /* Subroutine of handle_display_prop. Returns non-zero if the display
4112 specification in SPEC is a replacing specification, i.e. it would
4113 replace the text covered by `display' property with something else,
4114 such as an image or a display string.
4116 See handle_single_display_spec for documentation of arguments.
4117 frame_window_p is non-zero if the window being redisplayed is on a
4118 GUI frame; this argument is used only if IT is NULL, see below.
4120 IT can be NULL, if this is called by the bidi reordering code
4121 through compute_display_string_pos, which see. In that case, this
4122 function only examines SPEC, but does not otherwise "handle" it, in
4123 the sense that it doesn't set up members of IT from the display
4126 handle_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4127 Lisp_Object overlay
, struct text_pos
*position
,
4128 EMACS_INT bufpos
, int frame_window_p
)
4130 int replacing_p
= 0;
4133 /* Simple specerties. */
4134 && !EQ (XCAR (spec
), Qimage
)
4135 && !EQ (XCAR (spec
), Qspace
)
4136 && !EQ (XCAR (spec
), Qwhen
)
4137 && !EQ (XCAR (spec
), Qslice
)
4138 && !EQ (XCAR (spec
), Qspace_width
)
4139 && !EQ (XCAR (spec
), Qheight
)
4140 && !EQ (XCAR (spec
), Qraise
)
4141 /* Marginal area specifications. */
4142 && !(CONSP (XCAR (spec
)) && EQ (XCAR (XCAR (spec
)), Qmargin
))
4143 && !EQ (XCAR (spec
), Qleft_fringe
)
4144 && !EQ (XCAR (spec
), Qright_fringe
)
4145 && !NILP (XCAR (spec
)))
4147 for (; CONSP (spec
); spec
= XCDR (spec
))
4149 if (handle_single_display_spec (it
, XCAR (spec
), object
, overlay
,
4150 position
, bufpos
, replacing_p
,
4154 /* If some text in a string is replaced, `position' no
4155 longer points to the position of `object'. */
4156 if (!it
|| STRINGP (object
))
4161 else if (VECTORP (spec
))
4164 for (i
= 0; i
< ASIZE (spec
); ++i
)
4165 if (handle_single_display_spec (it
, AREF (spec
, i
), object
, overlay
,
4166 position
, bufpos
, replacing_p
,
4170 /* If some text in a string is replaced, `position' no
4171 longer points to the position of `object'. */
4172 if (!it
|| STRINGP (object
))
4178 if (handle_single_display_spec (it
, spec
, object
, overlay
,
4179 position
, bufpos
, 0, frame_window_p
))
4186 /* Value is the position of the end of the `display' property starting
4187 at START_POS in OBJECT. */
4189 static struct text_pos
4190 display_prop_end (struct it
*it
, Lisp_Object object
, struct text_pos start_pos
)
4193 struct text_pos end_pos
;
4195 end
= Fnext_single_char_property_change (make_number (CHARPOS (start_pos
)),
4196 Qdisplay
, object
, Qnil
);
4197 CHARPOS (end_pos
) = XFASTINT (end
);
4198 if (STRINGP (object
))
4199 compute_string_pos (&end_pos
, start_pos
, it
->string
);
4201 BYTEPOS (end_pos
) = CHAR_TO_BYTE (XFASTINT (end
));
4207 /* Set up IT from a single `display' property specification SPEC. OBJECT
4208 is the object in which the `display' property was found. *POSITION
4209 is the position in OBJECT at which the `display' property was found.
4210 BUFPOS is the buffer position of OBJECT (different from POSITION if
4211 OBJECT is not a buffer). DISPLAY_REPLACED_P non-zero means that we
4212 previously saw a display specification which already replaced text
4213 display with something else, for example an image; we ignore such
4214 properties after the first one has been processed.
4216 OVERLAY is the overlay this `display' property came from,
4217 or nil if it was a text property.
4219 If SPEC is a `space' or `image' specification, and in some other
4220 cases too, set *POSITION to the position where the `display'
4223 If IT is NULL, only examine the property specification in SPEC, but
4224 don't set up IT. In that case, FRAME_WINDOW_P non-zero means SPEC
4225 is intended to be displayed in a window on a GUI frame.
4227 Value is non-zero if something was found which replaces the display
4228 of buffer or string text. */
4231 handle_single_display_spec (struct it
*it
, Lisp_Object spec
, Lisp_Object object
,
4232 Lisp_Object overlay
, struct text_pos
*position
,
4233 EMACS_INT bufpos
, int display_replaced_p
,
4237 Lisp_Object location
, value
;
4238 struct text_pos start_pos
= *position
;
4241 /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
4242 If the result is non-nil, use VALUE instead of SPEC. */
4244 if (CONSP (spec
) && EQ (XCAR (spec
), Qwhen
))
4253 if (!NILP (form
) && !EQ (form
, Qt
))
4255 int count
= SPECPDL_INDEX ();
4256 struct gcpro gcpro1
;
4258 /* Bind `object' to the object having the `display' property, a
4259 buffer or string. Bind `position' to the position in the
4260 object where the property was found, and `buffer-position'
4261 to the current position in the buffer. */
4264 XSETBUFFER (object
, current_buffer
);
4265 specbind (Qobject
, object
);
4266 specbind (Qposition
, make_number (CHARPOS (*position
)));
4267 specbind (Qbuffer_position
, make_number (bufpos
));
4269 form
= safe_eval (form
);
4271 unbind_to (count
, Qnil
);
4277 /* Handle `(height HEIGHT)' specifications. */
4279 && EQ (XCAR (spec
), Qheight
)
4280 && CONSP (XCDR (spec
)))
4284 if (!FRAME_WINDOW_P (it
->f
))
4287 it
->font_height
= XCAR (XCDR (spec
));
4288 if (!NILP (it
->font_height
))
4290 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4291 int new_height
= -1;
4293 if (CONSP (it
->font_height
)
4294 && (EQ (XCAR (it
->font_height
), Qplus
)
4295 || EQ (XCAR (it
->font_height
), Qminus
))
4296 && CONSP (XCDR (it
->font_height
))
4297 && INTEGERP (XCAR (XCDR (it
->font_height
))))
4299 /* `(+ N)' or `(- N)' where N is an integer. */
4300 int steps
= XINT (XCAR (XCDR (it
->font_height
)));
4301 if (EQ (XCAR (it
->font_height
), Qplus
))
4303 it
->face_id
= smaller_face (it
->f
, it
->face_id
, steps
);
4305 else if (FUNCTIONP (it
->font_height
))
4307 /* Call function with current height as argument.
4308 Value is the new height. */
4310 height
= safe_call1 (it
->font_height
,
4311 face
->lface
[LFACE_HEIGHT_INDEX
]);
4312 if (NUMBERP (height
))
4313 new_height
= XFLOATINT (height
);
4315 else if (NUMBERP (it
->font_height
))
4317 /* Value is a multiple of the canonical char height. */
4320 f
= FACE_FROM_ID (it
->f
,
4321 lookup_basic_face (it
->f
, DEFAULT_FACE_ID
));
4322 new_height
= (XFLOATINT (it
->font_height
)
4323 * XINT (f
->lface
[LFACE_HEIGHT_INDEX
]));
4327 /* Evaluate IT->font_height with `height' bound to the
4328 current specified height to get the new height. */
4329 int count
= SPECPDL_INDEX ();
4331 specbind (Qheight
, face
->lface
[LFACE_HEIGHT_INDEX
]);
4332 value
= safe_eval (it
->font_height
);
4333 unbind_to (count
, Qnil
);
4335 if (NUMBERP (value
))
4336 new_height
= XFLOATINT (value
);
4340 it
->face_id
= face_with_height (it
->f
, it
->face_id
, new_height
);
4347 /* Handle `(space-width WIDTH)'. */
4349 && EQ (XCAR (spec
), Qspace_width
)
4350 && CONSP (XCDR (spec
)))
4354 if (!FRAME_WINDOW_P (it
->f
))
4357 value
= XCAR (XCDR (spec
));
4358 if (NUMBERP (value
) && XFLOATINT (value
) > 0)
4359 it
->space_width
= value
;
4365 /* Handle `(slice X Y WIDTH HEIGHT)'. */
4367 && EQ (XCAR (spec
), Qslice
))
4373 if (!FRAME_WINDOW_P (it
->f
))
4376 if (tem
= XCDR (spec
), CONSP (tem
))
4378 it
->slice
.x
= XCAR (tem
);
4379 if (tem
= XCDR (tem
), CONSP (tem
))
4381 it
->slice
.y
= XCAR (tem
);
4382 if (tem
= XCDR (tem
), CONSP (tem
))
4384 it
->slice
.width
= XCAR (tem
);
4385 if (tem
= XCDR (tem
), CONSP (tem
))
4386 it
->slice
.height
= XCAR (tem
);
4395 /* Handle `(raise FACTOR)'. */
4397 && EQ (XCAR (spec
), Qraise
)
4398 && CONSP (XCDR (spec
)))
4402 if (!FRAME_WINDOW_P (it
->f
))
4405 #ifdef HAVE_WINDOW_SYSTEM
4406 value
= XCAR (XCDR (spec
));
4407 if (NUMBERP (value
))
4409 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
4410 it
->voffset
= - (XFLOATINT (value
)
4411 * (FONT_HEIGHT (face
->font
)));
4413 #endif /* HAVE_WINDOW_SYSTEM */
4419 /* Don't handle the other kinds of display specifications
4420 inside a string that we got from a `display' property. */
4421 if (it
&& it
->string_from_display_prop_p
)
4424 /* Characters having this form of property are not displayed, so
4425 we have to find the end of the property. */
4428 start_pos
= *position
;
4429 *position
= display_prop_end (it
, object
, start_pos
);
4433 /* Stop the scan at that end position--we assume that all
4434 text properties change there. */
4436 it
->stop_charpos
= position
->charpos
;
4438 /* Handle `(left-fringe BITMAP [FACE])'
4439 and `(right-fringe BITMAP [FACE])'. */
4441 && (EQ (XCAR (spec
), Qleft_fringe
)
4442 || EQ (XCAR (spec
), Qright_fringe
))
4443 && CONSP (XCDR (spec
)))
4449 if (!FRAME_WINDOW_P (it
->f
))
4450 /* If we return here, POSITION has been advanced
4451 across the text with this property. */
4454 else if (!frame_window_p
)
4457 #ifdef HAVE_WINDOW_SYSTEM
4458 value
= XCAR (XCDR (spec
));
4459 if (!SYMBOLP (value
)
4460 || !(fringe_bitmap
= lookup_fringe_bitmap (value
)))
4461 /* If we return here, POSITION has been advanced
4462 across the text with this property. */
4467 int face_id
= lookup_basic_face (it
->f
, DEFAULT_FACE_ID
);;
4469 if (CONSP (XCDR (XCDR (spec
))))
4471 Lisp_Object face_name
= XCAR (XCDR (XCDR (spec
)));
4472 int face_id2
= lookup_derived_face (it
->f
, face_name
,
4478 /* Save current settings of IT so that we can restore them
4479 when we are finished with the glyph property value. */
4480 push_it (it
, position
);
4482 it
->area
= TEXT_AREA
;
4483 it
->what
= IT_IMAGE
;
4484 it
->image_id
= -1; /* no image */
4485 it
->position
= start_pos
;
4486 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4487 it
->method
= GET_FROM_IMAGE
;
4488 it
->from_overlay
= Qnil
;
4489 it
->face_id
= face_id
;
4490 it
->from_disp_prop_p
= 1;
4492 /* Say that we haven't consumed the characters with
4493 `display' property yet. The call to pop_it in
4494 set_iterator_to_next will clean this up. */
4495 *position
= start_pos
;
4497 if (EQ (XCAR (spec
), Qleft_fringe
))
4499 it
->left_user_fringe_bitmap
= fringe_bitmap
;
4500 it
->left_user_fringe_face_id
= face_id
;
4504 it
->right_user_fringe_bitmap
= fringe_bitmap
;
4505 it
->right_user_fringe_face_id
= face_id
;
4508 #endif /* HAVE_WINDOW_SYSTEM */
4512 /* Prepare to handle `((margin left-margin) ...)',
4513 `((margin right-margin) ...)' and `((margin nil) ...)'
4514 prefixes for display specifications. */
4515 location
= Qunbound
;
4516 if (CONSP (spec
) && CONSP (XCAR (spec
)))
4520 value
= XCDR (spec
);
4522 value
= XCAR (value
);
4525 if (EQ (XCAR (tem
), Qmargin
)
4526 && (tem
= XCDR (tem
),
4527 tem
= CONSP (tem
) ? XCAR (tem
) : Qnil
,
4529 || EQ (tem
, Qleft_margin
)
4530 || EQ (tem
, Qright_margin
))))
4534 if (EQ (location
, Qunbound
))
4540 /* After this point, VALUE is the property after any
4541 margin prefix has been stripped. It must be a string,
4542 an image specification, or `(space ...)'.
4544 LOCATION specifies where to display: `left-margin',
4545 `right-margin' or nil. */
4547 valid_p
= (STRINGP (value
)
4548 #ifdef HAVE_WINDOW_SYSTEM
4549 || ((it
? FRAME_WINDOW_P (it
->f
) : frame_window_p
)
4550 && valid_image_p (value
))
4551 #endif /* not HAVE_WINDOW_SYSTEM */
4552 || (CONSP (value
) && EQ (XCAR (value
), Qspace
)));
4554 if (valid_p
&& !display_replaced_p
)
4559 /* Save current settings of IT so that we can restore them
4560 when we are finished with the glyph property value. */
4561 push_it (it
, position
);
4562 it
->from_overlay
= overlay
;
4563 it
->from_disp_prop_p
= 1;
4565 if (NILP (location
))
4566 it
->area
= TEXT_AREA
;
4567 else if (EQ (location
, Qleft_margin
))
4568 it
->area
= LEFT_MARGIN_AREA
;
4570 it
->area
= RIGHT_MARGIN_AREA
;
4572 if (STRINGP (value
))
4575 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4576 it
->current
.overlay_string_index
= -1;
4577 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
4578 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
4579 it
->method
= GET_FROM_STRING
;
4580 it
->stop_charpos
= 0;
4582 it
->base_level_stop
= 0;
4583 it
->string_from_display_prop_p
= 1;
4584 /* Say that we haven't consumed the characters with
4585 `display' property yet. The call to pop_it in
4586 set_iterator_to_next will clean this up. */
4587 if (BUFFERP (object
))
4588 *position
= start_pos
;
4590 /* Force paragraph direction to be that of the parent
4591 object. If the parent object's paragraph direction is
4592 not yet determined, default to L2R. */
4593 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
4594 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
4596 it
->paragraph_embedding
= L2R
;
4598 /* Set up the bidi iterator for this display string. */
4601 it
->bidi_it
.string
.lstring
= it
->string
;
4602 it
->bidi_it
.string
.s
= NULL
;
4603 it
->bidi_it
.string
.schars
= it
->end_charpos
;
4604 it
->bidi_it
.string
.bufpos
= bufpos
;
4605 it
->bidi_it
.string
.from_disp_str
= 1;
4606 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
4607 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
4610 else if (CONSP (value
) && EQ (XCAR (value
), Qspace
))
4612 it
->method
= GET_FROM_STRETCH
;
4614 *position
= it
->position
= start_pos
;
4616 #ifdef HAVE_WINDOW_SYSTEM
4619 it
->what
= IT_IMAGE
;
4620 it
->image_id
= lookup_image (it
->f
, value
);
4621 it
->position
= start_pos
;
4622 it
->object
= NILP (object
) ? it
->w
->buffer
: object
;
4623 it
->method
= GET_FROM_IMAGE
;
4625 /* Say that we haven't consumed the characters with
4626 `display' property yet. The call to pop_it in
4627 set_iterator_to_next will clean this up. */
4628 *position
= start_pos
;
4630 #endif /* HAVE_WINDOW_SYSTEM */
4635 /* Invalid property or property not supported. Restore
4636 POSITION to what it was before. */
4637 *position
= start_pos
;
4641 /* Check if PROP is a display property value whose text should be
4642 treated as intangible. OVERLAY is the overlay from which PROP
4643 came, or nil if it came from a text property. CHARPOS and BYTEPOS
4644 specify the buffer position covered by PROP. */
4647 display_prop_intangible_p (Lisp_Object prop
, Lisp_Object overlay
,
4648 EMACS_INT charpos
, EMACS_INT bytepos
)
4650 int frame_window_p
= FRAME_WINDOW_P (XFRAME (selected_frame
));
4651 struct text_pos position
;
4653 SET_TEXT_POS (position
, charpos
, bytepos
);
4654 return handle_display_spec (NULL
, prop
, Qnil
, overlay
,
4655 &position
, charpos
, frame_window_p
);
4659 /* Return 1 if PROP is a display sub-property value containing STRING.
4661 Implementation note: this and the following function are really
4662 special cases of handle_display_spec and
4663 handle_single_display_spec, and should ideally use the same code.
4664 Until they do, these two pairs must be consistent and must be
4665 modified in sync. */
4668 single_display_spec_string_p (Lisp_Object prop
, Lisp_Object string
)
4670 if (EQ (string
, prop
))
4673 /* Skip over `when FORM'. */
4674 if (CONSP (prop
) && EQ (XCAR (prop
), Qwhen
))
4679 /* Actually, the condition following `when' should be eval'ed,
4680 like handle_single_display_spec does, and we should return
4681 zero if it evaluates to nil. However, this function is
4682 called only when the buffer was already displayed and some
4683 glyph in the glyph matrix was found to come from a display
4684 string. Therefore, the condition was already evaluated, and
4685 the result was non-nil, otherwise the display string wouldn't
4686 have been displayed and we would have never been called for
4687 this property. Thus, we can skip the evaluation and assume
4688 its result is non-nil. */
4693 /* Skip over `margin LOCATION'. */
4694 if (EQ (XCAR (prop
), Qmargin
))
4705 return EQ (prop
, string
) || (CONSP (prop
) && EQ (XCAR (prop
), string
));
4709 /* Return 1 if STRING appears in the `display' property PROP. */
4712 display_prop_string_p (Lisp_Object prop
, Lisp_Object string
)
4715 && !EQ (XCAR (prop
), Qwhen
)
4716 && !(CONSP (XCAR (prop
)) && EQ (Qmargin
, XCAR (XCAR (prop
)))))
4718 /* A list of sub-properties. */
4719 while (CONSP (prop
))
4721 if (single_display_spec_string_p (XCAR (prop
), string
))
4726 else if (VECTORP (prop
))
4728 /* A vector of sub-properties. */
4730 for (i
= 0; i
< ASIZE (prop
); ++i
)
4731 if (single_display_spec_string_p (AREF (prop
, i
), string
))
4735 return single_display_spec_string_p (prop
, string
);
4740 /* Look for STRING in overlays and text properties in the current
4741 buffer, between character positions FROM and TO (excluding TO).
4742 BACK_P non-zero means look back (in this case, TO is supposed to be
4744 Value is the first character position where STRING was found, or
4745 zero if it wasn't found before hitting TO.
4747 This function may only use code that doesn't eval because it is
4748 called asynchronously from note_mouse_highlight. */
4751 string_buffer_position_lim (Lisp_Object string
,
4752 EMACS_INT from
, EMACS_INT to
, int back_p
)
4754 Lisp_Object limit
, prop
, pos
;
4757 pos
= make_number (from
);
4759 if (!back_p
) /* looking forward */
4761 limit
= make_number (min (to
, ZV
));
4762 while (!found
&& !EQ (pos
, limit
))
4764 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4765 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4768 pos
= Fnext_single_char_property_change (pos
, Qdisplay
, Qnil
,
4772 else /* looking back */
4774 limit
= make_number (max (to
, BEGV
));
4775 while (!found
&& !EQ (pos
, limit
))
4777 prop
= Fget_char_property (pos
, Qdisplay
, Qnil
);
4778 if (!NILP (prop
) && display_prop_string_p (prop
, string
))
4781 pos
= Fprevious_single_char_property_change (pos
, Qdisplay
, Qnil
,
4786 return found
? XINT (pos
) : 0;
4789 /* Determine which buffer position in current buffer STRING comes from.
4790 AROUND_CHARPOS is an approximate position where it could come from.
4791 Value is the buffer position or 0 if it couldn't be determined.
4793 This function is necessary because we don't record buffer positions
4794 in glyphs generated from strings (to keep struct glyph small).
4795 This function may only use code that doesn't eval because it is
4796 called asynchronously from note_mouse_highlight. */
4799 string_buffer_position (Lisp_Object string
, EMACS_INT around_charpos
)
4801 const int MAX_DISTANCE
= 1000;
4802 EMACS_INT found
= string_buffer_position_lim (string
, around_charpos
,
4803 around_charpos
+ MAX_DISTANCE
,
4807 found
= string_buffer_position_lim (string
, around_charpos
,
4808 around_charpos
- MAX_DISTANCE
, 1);
4814 /***********************************************************************
4815 `composition' property
4816 ***********************************************************************/
4818 /* Set up iterator IT from `composition' property at its current
4819 position. Called from handle_stop. */
4821 static enum prop_handled
4822 handle_composition_prop (struct it
*it
)
4824 Lisp_Object prop
, string
;
4825 EMACS_INT pos
, pos_byte
, start
, end
;
4827 if (STRINGP (it
->string
))
4831 pos
= IT_STRING_CHARPOS (*it
);
4832 pos_byte
= IT_STRING_BYTEPOS (*it
);
4833 string
= it
->string
;
4834 s
= SDATA (string
) + pos_byte
;
4835 it
->c
= STRING_CHAR (s
);
4839 pos
= IT_CHARPOS (*it
);
4840 pos_byte
= IT_BYTEPOS (*it
);
4842 it
->c
= FETCH_CHAR (pos_byte
);
4845 /* If there's a valid composition and point is not inside of the
4846 composition (in the case that the composition is from the current
4847 buffer), draw a glyph composed from the composition components. */
4848 if (find_composition (pos
, -1, &start
, &end
, &prop
, string
)
4849 && COMPOSITION_VALID_P (start
, end
, prop
)
4850 && (STRINGP (it
->string
) || (PT
<= start
|| PT
>= end
)))
4854 if (STRINGP (it
->string
))
4855 pos_byte
= string_char_to_byte (it
->string
, start
);
4857 pos_byte
= CHAR_TO_BYTE (start
);
4859 it
->cmp_it
.id
= get_composition_id (start
, pos_byte
, end
- start
,
4862 if (it
->cmp_it
.id
>= 0)
4865 it
->cmp_it
.nchars
= COMPOSITION_LENGTH (prop
);
4866 it
->cmp_it
.nglyphs
= -1;
4870 return HANDLED_NORMALLY
;
4875 /***********************************************************************
4877 ***********************************************************************/
4879 /* The following structure is used to record overlay strings for
4880 later sorting in load_overlay_strings. */
4882 struct overlay_entry
4884 Lisp_Object overlay
;
4891 /* Set up iterator IT from overlay strings at its current position.
4892 Called from handle_stop. */
4894 static enum prop_handled
4895 handle_overlay_change (struct it
*it
)
4897 if (!STRINGP (it
->string
) && get_overlay_strings (it
, 0))
4898 return HANDLED_RECOMPUTE_PROPS
;
4900 return HANDLED_NORMALLY
;
4904 /* Set up the next overlay string for delivery by IT, if there is an
4905 overlay string to deliver. Called by set_iterator_to_next when the
4906 end of the current overlay string is reached. If there are more
4907 overlay strings to display, IT->string and
4908 IT->current.overlay_string_index are set appropriately here.
4909 Otherwise IT->string is set to nil. */
4912 next_overlay_string (struct it
*it
)
4914 ++it
->current
.overlay_string_index
;
4915 if (it
->current
.overlay_string_index
== it
->n_overlay_strings
)
4917 /* No more overlay strings. Restore IT's settings to what
4918 they were before overlay strings were processed, and
4919 continue to deliver from current_buffer. */
4921 it
->ellipsis_p
= (it
->stack
[it
->sp
- 1].display_ellipsis_p
!= 0);
4924 || (NILP (it
->string
)
4925 && it
->method
== GET_FROM_BUFFER
4926 && it
->stop_charpos
>= BEGV
4927 && it
->stop_charpos
<= it
->end_charpos
));
4928 it
->current
.overlay_string_index
= -1;
4929 it
->n_overlay_strings
= 0;
4930 it
->overlay_strings_charpos
= -1;
4932 /* If we're at the end of the buffer, record that we have
4933 processed the overlay strings there already, so that
4934 next_element_from_buffer doesn't try it again. */
4935 if (NILP (it
->string
) && IT_CHARPOS (*it
) >= it
->end_charpos
)
4936 it
->overlay_strings_at_end_processed_p
= 1;
4940 /* There are more overlay strings to process. If
4941 IT->current.overlay_string_index has advanced to a position
4942 where we must load IT->overlay_strings with more strings, do
4943 it. We must load at the IT->overlay_strings_charpos where
4944 IT->n_overlay_strings was originally computed; when invisible
4945 text is present, this might not be IT_CHARPOS (Bug#7016). */
4946 int i
= it
->current
.overlay_string_index
% OVERLAY_STRING_CHUNK_SIZE
;
4948 if (it
->current
.overlay_string_index
&& i
== 0)
4949 load_overlay_strings (it
, it
->overlay_strings_charpos
);
4951 /* Initialize IT to deliver display elements from the overlay
4953 it
->string
= it
->overlay_strings
[i
];
4954 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
4955 SET_TEXT_POS (it
->current
.string_pos
, 0, 0);
4956 it
->method
= GET_FROM_STRING
;
4957 it
->stop_charpos
= 0;
4958 if (it
->cmp_it
.stop_pos
>= 0)
4959 it
->cmp_it
.stop_pos
= 0;
4961 it
->base_level_stop
= 0;
4963 /* Set up the bidi iterator for this overlay string. */
4966 it
->bidi_it
.string
.lstring
= it
->string
;
4967 it
->bidi_it
.string
.s
= NULL
;
4968 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
4969 it
->bidi_it
.string
.bufpos
= it
->overlay_strings_charpos
;
4970 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
4971 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
4972 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
4980 /* Compare two overlay_entry structures E1 and E2. Used as a
4981 comparison function for qsort in load_overlay_strings. Overlay
4982 strings for the same position are sorted so that
4984 1. All after-strings come in front of before-strings, except
4985 when they come from the same overlay.
4987 2. Within after-strings, strings are sorted so that overlay strings
4988 from overlays with higher priorities come first.
4990 2. Within before-strings, strings are sorted so that overlay
4991 strings from overlays with higher priorities come last.
4993 Value is analogous to strcmp. */
4997 compare_overlay_entries (const void *e1
, const void *e2
)
4999 struct overlay_entry
*entry1
= (struct overlay_entry
*) e1
;
5000 struct overlay_entry
*entry2
= (struct overlay_entry
*) e2
;
5003 if (entry1
->after_string_p
!= entry2
->after_string_p
)
5005 /* Let after-strings appear in front of before-strings if
5006 they come from different overlays. */
5007 if (EQ (entry1
->overlay
, entry2
->overlay
))
5008 result
= entry1
->after_string_p
? 1 : -1;
5010 result
= entry1
->after_string_p
? -1 : 1;
5012 else if (entry1
->after_string_p
)
5013 /* After-strings sorted in order of decreasing priority. */
5014 result
= entry2
->priority
- entry1
->priority
;
5016 /* Before-strings sorted in order of increasing priority. */
5017 result
= entry1
->priority
- entry2
->priority
;
5023 /* Load the vector IT->overlay_strings with overlay strings from IT's
5024 current buffer position, or from CHARPOS if that is > 0. Set
5025 IT->n_overlays to the total number of overlay strings found.
5027 Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
5028 a time. On entry into load_overlay_strings,
5029 IT->current.overlay_string_index gives the number of overlay
5030 strings that have already been loaded by previous calls to this
5033 IT->add_overlay_start contains an additional overlay start
5034 position to consider for taking overlay strings from, if non-zero.
5035 This position comes into play when the overlay has an `invisible'
5036 property, and both before and after-strings. When we've skipped to
5037 the end of the overlay, because of its `invisible' property, we
5038 nevertheless want its before-string to appear.
5039 IT->add_overlay_start will contain the overlay start position
5042 Overlay strings are sorted so that after-string strings come in
5043 front of before-string strings. Within before and after-strings,
5044 strings are sorted by overlay priority. See also function
5045 compare_overlay_entries. */
5048 load_overlay_strings (struct it
*it
, EMACS_INT charpos
)
5050 Lisp_Object overlay
, window
, str
, invisible
;
5051 struct Lisp_Overlay
*ov
;
5052 EMACS_INT start
, end
;
5054 int n
= 0, i
, j
, invis_p
;
5055 struct overlay_entry
*entries
5056 = (struct overlay_entry
*) alloca (size
* sizeof *entries
);
5059 charpos
= IT_CHARPOS (*it
);
5061 /* Append the overlay string STRING of overlay OVERLAY to vector
5062 `entries' which has size `size' and currently contains `n'
5063 elements. AFTER_P non-zero means STRING is an after-string of
5065 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P) \
5068 Lisp_Object priority; \
5072 int new_size = 2 * size; \
5073 struct overlay_entry *old = entries; \
5075 (struct overlay_entry *) alloca (new_size \
5076 * sizeof *entries); \
5077 memcpy (entries, old, size * sizeof *entries); \
5081 entries[n].string = (STRING); \
5082 entries[n].overlay = (OVERLAY); \
5083 priority = Foverlay_get ((OVERLAY), Qpriority); \
5084 entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
5085 entries[n].after_string_p = (AFTER_P); \
5090 /* Process overlay before the overlay center. */
5091 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
5093 XSETMISC (overlay
, ov
);
5094 xassert (OVERLAYP (overlay
));
5095 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5096 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5101 /* Skip this overlay if it doesn't start or end at IT's current
5103 if (end
!= charpos
&& start
!= charpos
)
5106 /* Skip this overlay if it doesn't apply to IT->w. */
5107 window
= Foverlay_get (overlay
, Qwindow
);
5108 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5111 /* If the text ``under'' the overlay is invisible, both before-
5112 and after-strings from this overlay are visible; start and
5113 end position are indistinguishable. */
5114 invisible
= Foverlay_get (overlay
, Qinvisible
);
5115 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5117 /* If overlay has a non-empty before-string, record it. */
5118 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5119 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5121 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5123 /* If overlay has a non-empty after-string, record it. */
5124 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5125 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5127 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5130 /* Process overlays after the overlay center. */
5131 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
5133 XSETMISC (overlay
, ov
);
5134 xassert (OVERLAYP (overlay
));
5135 start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
5136 end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
5138 if (start
> charpos
)
5141 /* Skip this overlay if it doesn't start or end at IT's current
5143 if (end
!= charpos
&& start
!= charpos
)
5146 /* Skip this overlay if it doesn't apply to IT->w. */
5147 window
= Foverlay_get (overlay
, Qwindow
);
5148 if (WINDOWP (window
) && XWINDOW (window
) != it
->w
)
5151 /* If the text ``under'' the overlay is invisible, it has a zero
5152 dimension, and both before- and after-strings apply. */
5153 invisible
= Foverlay_get (overlay
, Qinvisible
);
5154 invis_p
= TEXT_PROP_MEANS_INVISIBLE (invisible
);
5156 /* If overlay has a non-empty before-string, record it. */
5157 if ((start
== charpos
|| (end
== charpos
&& invis_p
))
5158 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
))
5160 RECORD_OVERLAY_STRING (overlay
, str
, 0);
5162 /* If overlay has a non-empty after-string, record it. */
5163 if ((end
== charpos
|| (start
== charpos
&& invis_p
))
5164 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
))
5166 RECORD_OVERLAY_STRING (overlay
, str
, 1);
5169 #undef RECORD_OVERLAY_STRING
5173 qsort (entries
, n
, sizeof *entries
, compare_overlay_entries
);
5175 /* Record number of overlay strings, and where we computed it. */
5176 it
->n_overlay_strings
= n
;
5177 it
->overlay_strings_charpos
= charpos
;
5179 /* IT->current.overlay_string_index is the number of overlay strings
5180 that have already been consumed by IT. Copy some of the
5181 remaining overlay strings to IT->overlay_strings. */
5183 j
= it
->current
.overlay_string_index
;
5184 while (i
< OVERLAY_STRING_CHUNK_SIZE
&& j
< n
)
5186 it
->overlay_strings
[i
] = entries
[j
].string
;
5187 it
->string_overlays
[i
++] = entries
[j
++].overlay
;
5194 /* Get the first chunk of overlay strings at IT's current buffer
5195 position, or at CHARPOS if that is > 0. Value is non-zero if at
5196 least one overlay string was found. */
5199 get_overlay_strings_1 (struct it
*it
, EMACS_INT charpos
, int compute_stop_p
)
5201 /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
5202 process. This fills IT->overlay_strings with strings, and sets
5203 IT->n_overlay_strings to the total number of strings to process.
5204 IT->pos.overlay_string_index has to be set temporarily to zero
5205 because load_overlay_strings needs this; it must be set to -1
5206 when no overlay strings are found because a zero value would
5207 indicate a position in the first overlay string. */
5208 it
->current
.overlay_string_index
= 0;
5209 load_overlay_strings (it
, charpos
);
5211 /* If we found overlay strings, set up IT to deliver display
5212 elements from the first one. Otherwise set up IT to deliver
5213 from current_buffer. */
5214 if (it
->n_overlay_strings
)
5216 /* Make sure we know settings in current_buffer, so that we can
5217 restore meaningful values when we're done with the overlay
5220 compute_stop_pos (it
);
5221 xassert (it
->face_id
>= 0);
5223 /* Save IT's settings. They are restored after all overlay
5224 strings have been processed. */
5225 xassert (!compute_stop_p
|| it
->sp
== 0);
5227 /* When called from handle_stop, there might be an empty display
5228 string loaded. In that case, don't bother saving it. */
5229 if (!STRINGP (it
->string
) || SCHARS (it
->string
))
5232 /* Set up IT to deliver display elements from the first overlay
5234 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
5235 it
->string
= it
->overlay_strings
[0];
5236 it
->from_overlay
= Qnil
;
5237 it
->stop_charpos
= 0;
5238 xassert (STRINGP (it
->string
));
5239 it
->end_charpos
= SCHARS (it
->string
);
5241 it
->base_level_stop
= 0;
5242 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
5243 it
->method
= GET_FROM_STRING
;
5244 it
->from_disp_prop_p
= 0;
5246 /* Force paragraph direction to be that of the parent
5248 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
5249 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
5251 it
->paragraph_embedding
= L2R
;
5253 /* Set up the bidi iterator for this overlay string. */
5256 EMACS_INT pos
= (charpos
> 0 ? charpos
: IT_CHARPOS (*it
));
5258 it
->bidi_it
.string
.lstring
= it
->string
;
5259 it
->bidi_it
.string
.s
= NULL
;
5260 it
->bidi_it
.string
.schars
= SCHARS (it
->string
);
5261 it
->bidi_it
.string
.bufpos
= pos
;
5262 it
->bidi_it
.string
.from_disp_str
= it
->string_from_display_prop_p
;
5263 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5264 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5269 it
->current
.overlay_string_index
= -1;
5274 get_overlay_strings (struct it
*it
, EMACS_INT charpos
)
5277 it
->method
= GET_FROM_BUFFER
;
5279 (void) get_overlay_strings_1 (it
, charpos
, 1);
5283 /* Value is non-zero if we found at least one overlay string. */
5284 return STRINGP (it
->string
);
5289 /***********************************************************************
5290 Saving and restoring state
5291 ***********************************************************************/
5293 /* Save current settings of IT on IT->stack. Called, for example,
5294 before setting up IT for an overlay string, to be able to restore
5295 IT's settings to what they were after the overlay string has been
5296 processed. If POSITION is non-NULL, it is the position to save on
5297 the stack instead of IT->position. */
5300 push_it (struct it
*it
, struct text_pos
*position
)
5302 struct iterator_stack_entry
*p
;
5304 xassert (it
->sp
< IT_STACK_SIZE
);
5305 p
= it
->stack
+ it
->sp
;
5307 p
->stop_charpos
= it
->stop_charpos
;
5308 p
->prev_stop
= it
->prev_stop
;
5309 p
->base_level_stop
= it
->base_level_stop
;
5310 p
->cmp_it
= it
->cmp_it
;
5311 xassert (it
->face_id
>= 0);
5312 p
->face_id
= it
->face_id
;
5313 p
->string
= it
->string
;
5314 p
->method
= it
->method
;
5315 p
->from_overlay
= it
->from_overlay
;
5318 case GET_FROM_IMAGE
:
5319 p
->u
.image
.object
= it
->object
;
5320 p
->u
.image
.image_id
= it
->image_id
;
5321 p
->u
.image
.slice
= it
->slice
;
5323 case GET_FROM_STRETCH
:
5324 p
->u
.stretch
.object
= it
->object
;
5327 p
->position
= position
? *position
: it
->position
;
5328 p
->current
= it
->current
;
5329 p
->end_charpos
= it
->end_charpos
;
5330 p
->string_nchars
= it
->string_nchars
;
5332 p
->multibyte_p
= it
->multibyte_p
;
5333 p
->avoid_cursor_p
= it
->avoid_cursor_p
;
5334 p
->space_width
= it
->space_width
;
5335 p
->font_height
= it
->font_height
;
5336 p
->voffset
= it
->voffset
;
5337 p
->string_from_display_prop_p
= it
->string_from_display_prop_p
;
5338 p
->display_ellipsis_p
= 0;
5339 p
->line_wrap
= it
->line_wrap
;
5340 p
->bidi_p
= it
->bidi_p
;
5341 p
->paragraph_embedding
= it
->paragraph_embedding
;
5342 p
->from_disp_prop_p
= it
->from_disp_prop_p
;
5345 /* Save the state of the bidi iterator as well. */
5347 bidi_push_it (&it
->bidi_it
);
5351 iterate_out_of_display_property (struct it
*it
)
5353 int buffer_p
= BUFFERP (it
->object
);
5354 EMACS_INT eob
= (buffer_p
? ZV
: it
->end_charpos
);
5355 EMACS_INT bob
= (buffer_p
? BEGV
: 0);
5357 /* Maybe initialize paragraph direction. If we are at the beginning
5358 of a new paragraph, next_element_from_buffer may not have a
5359 chance to do that. */
5360 if (it
->bidi_it
.first_elt
&& it
->bidi_it
.charpos
< eob
)
5361 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
5362 /* prev_stop can be zero, so check against BEGV as well. */
5363 while (it
->bidi_it
.charpos
>= bob
5364 && it
->prev_stop
<= it
->bidi_it
.charpos
5365 && it
->bidi_it
.charpos
< CHARPOS (it
->position
))
5366 bidi_move_to_visually_next (&it
->bidi_it
);
5367 /* Record the stop_pos we just crossed, for when we cross it
5369 if (it
->bidi_it
.charpos
> CHARPOS (it
->position
))
5370 it
->prev_stop
= CHARPOS (it
->position
);
5371 /* If we ended up not where pop_it put us, resync IT's
5372 positional members with the bidi iterator. */
5373 if (it
->bidi_it
.charpos
!= CHARPOS (it
->position
))
5375 SET_TEXT_POS (it
->position
,
5376 it
->bidi_it
.charpos
, it
->bidi_it
.bytepos
);
5378 it
->current
.pos
= it
->position
;
5380 it
->current
.string_pos
= it
->position
;
5384 /* Restore IT's settings from IT->stack. Called, for example, when no
5385 more overlay strings must be processed, and we return to delivering
5386 display elements from a buffer, or when the end of a string from a
5387 `display' property is reached and we return to delivering display
5388 elements from an overlay string, or from a buffer. */
5391 pop_it (struct it
*it
)
5393 struct iterator_stack_entry
*p
;
5394 int from_display_prop
= it
->from_disp_prop_p
;
5396 xassert (it
->sp
> 0);
5398 p
= it
->stack
+ it
->sp
;
5399 it
->stop_charpos
= p
->stop_charpos
;
5400 it
->prev_stop
= p
->prev_stop
;
5401 it
->base_level_stop
= p
->base_level_stop
;
5402 it
->cmp_it
= p
->cmp_it
;
5403 it
->face_id
= p
->face_id
;
5404 it
->current
= p
->current
;
5405 it
->position
= p
->position
;
5406 it
->string
= p
->string
;
5407 it
->from_overlay
= p
->from_overlay
;
5408 if (NILP (it
->string
))
5409 SET_TEXT_POS (it
->current
.string_pos
, -1, -1);
5410 it
->method
= p
->method
;
5413 case GET_FROM_IMAGE
:
5414 it
->image_id
= p
->u
.image
.image_id
;
5415 it
->object
= p
->u
.image
.object
;
5416 it
->slice
= p
->u
.image
.slice
;
5418 case GET_FROM_STRETCH
:
5419 it
->object
= p
->u
.stretch
.object
;
5421 case GET_FROM_BUFFER
:
5422 it
->object
= it
->w
->buffer
;
5424 case GET_FROM_STRING
:
5425 it
->object
= it
->string
;
5427 case GET_FROM_DISPLAY_VECTOR
:
5429 it
->method
= GET_FROM_C_STRING
;
5430 else if (STRINGP (it
->string
))
5431 it
->method
= GET_FROM_STRING
;
5434 it
->method
= GET_FROM_BUFFER
;
5435 it
->object
= it
->w
->buffer
;
5438 it
->end_charpos
= p
->end_charpos
;
5439 it
->string_nchars
= p
->string_nchars
;
5441 it
->multibyte_p
= p
->multibyte_p
;
5442 it
->avoid_cursor_p
= p
->avoid_cursor_p
;
5443 it
->space_width
= p
->space_width
;
5444 it
->font_height
= p
->font_height
;
5445 it
->voffset
= p
->voffset
;
5446 it
->string_from_display_prop_p
= p
->string_from_display_prop_p
;
5447 it
->line_wrap
= p
->line_wrap
;
5448 it
->bidi_p
= p
->bidi_p
;
5449 it
->paragraph_embedding
= p
->paragraph_embedding
;
5450 it
->from_disp_prop_p
= p
->from_disp_prop_p
;
5453 bidi_pop_it (&it
->bidi_it
);
5454 /* Bidi-iterate until we get out of the portion of text, if any,
5455 covered by a `display' text property or by an overlay with
5456 `display' property. (We cannot just jump there, because the
5457 internal coherency of the bidi iterator state can not be
5458 preserved across such jumps.) We also must determine the
5459 paragraph base direction if the overlay we just processed is
5460 at the beginning of a new paragraph. */
5461 if (from_display_prop
5462 && (it
->method
== GET_FROM_BUFFER
|| it
->method
== GET_FROM_STRING
))
5463 iterate_out_of_display_property (it
);
5465 xassert ((BUFFERP (it
->object
)
5466 && IT_CHARPOS (*it
) == it
->bidi_it
.charpos
5467 && IT_BYTEPOS (*it
) == it
->bidi_it
.bytepos
)
5468 || (STRINGP (it
->object
)
5469 && IT_STRING_CHARPOS (*it
) == it
->bidi_it
.charpos
5470 && IT_STRING_BYTEPOS (*it
) == it
->bidi_it
.bytepos
));
5476 /***********************************************************************
5478 ***********************************************************************/
5480 /* Set IT's current position to the previous line start. */
5483 back_to_previous_line_start (struct it
*it
)
5485 IT_CHARPOS (*it
) = find_next_newline_no_quit (IT_CHARPOS (*it
) - 1, -1);
5486 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (IT_CHARPOS (*it
));
5490 /* Move IT to the next line start.
5492 Value is non-zero if a newline was found. Set *SKIPPED_P to 1 if
5493 we skipped over part of the text (as opposed to moving the iterator
5494 continuously over the text). Otherwise, don't change the value
5497 Newlines may come from buffer text, overlay strings, or strings
5498 displayed via the `display' property. That's the reason we can't
5499 simply use find_next_newline_no_quit.
5501 Note that this function may not skip over invisible text that is so
5502 because of text properties and immediately follows a newline. If
5503 it would, function reseat_at_next_visible_line_start, when called
5504 from set_iterator_to_next, would effectively make invisible
5505 characters following a newline part of the wrong glyph row, which
5506 leads to wrong cursor motion. */
5509 forward_to_next_line_start (struct it
*it
, int *skipped_p
)
5511 int old_selective
, newline_found_p
, n
;
5512 const int MAX_NEWLINE_DISTANCE
= 500;
5514 /* If already on a newline, just consume it to avoid unintended
5515 skipping over invisible text below. */
5516 if (it
->what
== IT_CHARACTER
5518 && CHARPOS (it
->position
) == IT_CHARPOS (*it
))
5520 set_iterator_to_next (it
, 0);
5525 /* Don't handle selective display in the following. It's (a)
5526 unnecessary because it's done by the caller, and (b) leads to an
5527 infinite recursion because next_element_from_ellipsis indirectly
5528 calls this function. */
5529 old_selective
= it
->selective
;
5532 /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
5533 from buffer text. */
5534 for (n
= newline_found_p
= 0;
5535 !newline_found_p
&& n
< MAX_NEWLINE_DISTANCE
;
5536 n
+= STRINGP (it
->string
) ? 0 : 1)
5538 if (!get_next_display_element (it
))
5540 newline_found_p
= it
->what
== IT_CHARACTER
&& it
->c
== '\n';
5541 set_iterator_to_next (it
, 0);
5544 /* If we didn't find a newline near enough, see if we can use a
5546 if (!newline_found_p
)
5548 EMACS_INT start
= IT_CHARPOS (*it
);
5549 EMACS_INT limit
= find_next_newline_no_quit (start
, 1);
5552 xassert (!STRINGP (it
->string
));
5554 /* If we are not bidi-reordering, and there isn't any `display'
5555 property in sight, and no overlays, we can just use the
5556 position of the newline in buffer text. */
5558 && (it
->stop_charpos
>= limit
5559 || ((pos
= Fnext_single_property_change (make_number (start
),
5561 make_number (limit
)),
5563 && next_overlay_change (start
) == ZV
)))
5565 IT_CHARPOS (*it
) = limit
;
5566 IT_BYTEPOS (*it
) = CHAR_TO_BYTE (limit
);
5567 *skipped_p
= newline_found_p
= 1;
5571 while (get_next_display_element (it
)
5572 && !newline_found_p
)
5574 newline_found_p
= ITERATOR_AT_END_OF_LINE_P (it
);
5575 set_iterator_to_next (it
, 0);
5580 it
->selective
= old_selective
;
5581 return newline_found_p
;
5585 /* Set IT's current position to the previous visible line start. Skip
5586 invisible text that is so either due to text properties or due to
5587 selective display. Caution: this does not change IT->current_x and
5591 back_to_previous_visible_line_start (struct it
*it
)
5593 while (IT_CHARPOS (*it
) > BEGV
)
5595 back_to_previous_line_start (it
);
5597 if (IT_CHARPOS (*it
) <= BEGV
)
5600 /* If selective > 0, then lines indented more than its value are
5602 if (it
->selective
> 0
5603 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5604 (double) it
->selective
)) /* iftc */
5607 /* Check the newline before point for invisibility. */
5610 prop
= Fget_char_property (make_number (IT_CHARPOS (*it
) - 1),
5611 Qinvisible
, it
->window
);
5612 if (TEXT_PROP_MEANS_INVISIBLE (prop
))
5616 if (IT_CHARPOS (*it
) <= BEGV
)
5621 void *it2data
= NULL
;
5624 Lisp_Object val
, overlay
;
5626 SAVE_IT (it2
, *it
, it2data
);
5628 /* If newline is part of a composition, continue from start of composition */
5629 if (find_composition (IT_CHARPOS (*it
), -1, &beg
, &end
, &val
, Qnil
)
5630 && beg
< IT_CHARPOS (*it
))
5633 /* If newline is replaced by a display property, find start of overlay
5634 or interval and continue search from that point. */
5635 pos
= --IT_CHARPOS (it2
);
5638 bidi_unshelve_cache (NULL
);
5639 it2
.string_from_display_prop_p
= 0;
5640 it2
.from_disp_prop_p
= 0;
5641 if (handle_display_prop (&it2
) == HANDLED_RETURN
5642 && !NILP (val
= get_char_property_and_overlay
5643 (make_number (pos
), Qdisplay
, Qnil
, &overlay
))
5644 && (OVERLAYP (overlay
)
5645 ? (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)))
5646 : get_property_and_range (pos
, Qdisplay
, &val
, &beg
, &end
, Qnil
)))
5648 RESTORE_IT (it
, it
, it2data
);
5652 /* Newline is not replaced by anything -- so we are done. */
5653 RESTORE_IT (it
, it
, it2data
);
5659 IT_CHARPOS (*it
) = beg
;
5660 IT_BYTEPOS (*it
) = buf_charpos_to_bytepos (current_buffer
, beg
);
5664 it
->continuation_lines_width
= 0;
5666 xassert (IT_CHARPOS (*it
) >= BEGV
);
5667 xassert (IT_CHARPOS (*it
) == BEGV
5668 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5673 /* Reseat iterator IT at the previous visible line start. Skip
5674 invisible text that is so either due to text properties or due to
5675 selective display. At the end, update IT's overlay information,
5676 face information etc. */
5679 reseat_at_previous_visible_line_start (struct it
*it
)
5681 back_to_previous_visible_line_start (it
);
5682 reseat (it
, it
->current
.pos
, 1);
5687 /* Reseat iterator IT on the next visible line start in the current
5688 buffer. ON_NEWLINE_P non-zero means position IT on the newline
5689 preceding the line start. Skip over invisible text that is so
5690 because of selective display. Compute faces, overlays etc at the
5691 new position. Note that this function does not skip over text that
5692 is invisible because of text properties. */
5695 reseat_at_next_visible_line_start (struct it
*it
, int on_newline_p
)
5697 int newline_found_p
, skipped_p
= 0;
5699 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5701 /* Skip over lines that are invisible because they are indented
5702 more than the value of IT->selective. */
5703 if (it
->selective
> 0)
5704 while (IT_CHARPOS (*it
) < ZV
5705 && indented_beyond_p (IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
5706 (double) it
->selective
)) /* iftc */
5708 xassert (IT_BYTEPOS (*it
) == BEGV
5709 || FETCH_BYTE (IT_BYTEPOS (*it
) - 1) == '\n');
5710 newline_found_p
= forward_to_next_line_start (it
, &skipped_p
);
5713 /* Position on the newline if that's what's requested. */
5714 if (on_newline_p
&& newline_found_p
)
5716 if (STRINGP (it
->string
))
5718 if (IT_STRING_CHARPOS (*it
) > 0)
5722 --IT_STRING_CHARPOS (*it
);
5723 --IT_STRING_BYTEPOS (*it
);
5726 /* Setting this flag will cause
5727 bidi_move_to_visually_next not to advance, but
5728 instead deliver the current character (newline),
5729 which is what the ON_NEWLINE_P flag wants. */
5730 it
->bidi_it
.first_elt
= 1;
5733 else if (IT_CHARPOS (*it
) > BEGV
)
5740 /* With bidi iteration, the call to `reseat' will cause
5741 bidi_move_to_visually_next deliver the current character,
5742 the newline, instead of advancing. */
5743 reseat (it
, it
->current
.pos
, 0);
5747 reseat (it
, it
->current
.pos
, 0);
5754 /***********************************************************************
5755 Changing an iterator's position
5756 ***********************************************************************/
5758 /* Change IT's current position to POS in current_buffer. If FORCE_P
5759 is non-zero, always check for text properties at the new position.
5760 Otherwise, text properties are only looked up if POS >=
5761 IT->check_charpos of a property. */
5764 reseat (struct it
*it
, struct text_pos pos
, int force_p
)
5766 EMACS_INT original_pos
= IT_CHARPOS (*it
);
5768 reseat_1 (it
, pos
, 0);
5770 /* Determine where to check text properties. Avoid doing it
5771 where possible because text property lookup is very expensive. */
5773 || CHARPOS (pos
) > it
->stop_charpos
5774 || CHARPOS (pos
) < original_pos
)
5778 /* For bidi iteration, we need to prime prev_stop and
5779 base_level_stop with our best estimations. */
5780 if (CHARPOS (pos
) != it
->prev_stop
)
5781 it
->prev_stop
= CHARPOS (pos
);
5782 if (CHARPOS (pos
) < it
->base_level_stop
)
5783 it
->base_level_stop
= 0;
5789 it
->prev_stop
= it
->base_level_stop
= 0;
5798 /* Change IT's buffer position to POS. SET_STOP_P non-zero means set
5799 IT->stop_pos to POS, also. */
5802 reseat_1 (struct it
*it
, struct text_pos pos
, int set_stop_p
)
5804 /* Don't call this function when scanning a C string. */
5805 xassert (it
->s
== NULL
);
5807 /* POS must be a reasonable value. */
5808 xassert (CHARPOS (pos
) >= BEGV
&& CHARPOS (pos
) <= ZV
);
5810 it
->current
.pos
= it
->position
= pos
;
5811 it
->end_charpos
= ZV
;
5813 it
->current
.dpvec_index
= -1;
5814 it
->current
.overlay_string_index
= -1;
5815 IT_STRING_CHARPOS (*it
) = -1;
5816 IT_STRING_BYTEPOS (*it
) = -1;
5818 it
->method
= GET_FROM_BUFFER
;
5819 it
->object
= it
->w
->buffer
;
5820 it
->area
= TEXT_AREA
;
5821 it
->multibyte_p
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
5823 it
->string_from_display_prop_p
= 0;
5824 it
->from_disp_prop_p
= 0;
5825 it
->face_before_selective_p
= 0;
5828 bidi_init_it (IT_CHARPOS (*it
), IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
5830 bidi_unshelve_cache (NULL
);
5831 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
5832 it
->bidi_it
.string
.s
= NULL
;
5833 it
->bidi_it
.string
.lstring
= Qnil
;
5834 it
->bidi_it
.string
.bufpos
= 0;
5835 it
->bidi_it
.string
.unibyte
= 0;
5840 it
->stop_charpos
= CHARPOS (pos
);
5841 it
->base_level_stop
= CHARPOS (pos
);
5846 /* Set up IT for displaying a string, starting at CHARPOS in window W.
5847 If S is non-null, it is a C string to iterate over. Otherwise,
5848 STRING gives a Lisp string to iterate over.
5850 If PRECISION > 0, don't return more then PRECISION number of
5851 characters from the string.
5853 If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
5854 characters have been returned. FIELD_WIDTH < 0 means an infinite
5857 MULTIBYTE = 0 means disable processing of multibyte characters,
5858 MULTIBYTE > 0 means enable it,
5859 MULTIBYTE < 0 means use IT->multibyte_p.
5861 IT must be initialized via a prior call to init_iterator before
5862 calling this function. */
5865 reseat_to_string (struct it
*it
, const char *s
, Lisp_Object string
,
5866 EMACS_INT charpos
, EMACS_INT precision
, int field_width
,
5869 /* No region in strings. */
5870 it
->region_beg_charpos
= it
->region_end_charpos
= -1;
5872 /* No text property checks performed by default, but see below. */
5873 it
->stop_charpos
= -1;
5875 /* Set iterator position and end position. */
5876 memset (&it
->current
, 0, sizeof it
->current
);
5877 it
->current
.overlay_string_index
= -1;
5878 it
->current
.dpvec_index
= -1;
5879 xassert (charpos
>= 0);
5881 /* If STRING is specified, use its multibyteness, otherwise use the
5882 setting of MULTIBYTE, if specified. */
5884 it
->multibyte_p
= multibyte
> 0;
5886 /* Bidirectional reordering of strings is controlled by the default
5887 value of bidi-display-reordering. */
5888 it
->bidi_p
= !NILP (BVAR (&buffer_defaults
, bidi_display_reordering
));
5892 xassert (STRINGP (string
));
5893 it
->string
= string
;
5895 it
->end_charpos
= it
->string_nchars
= SCHARS (string
);
5896 it
->method
= GET_FROM_STRING
;
5897 it
->current
.string_pos
= string_pos (charpos
, string
);
5901 it
->bidi_it
.string
.lstring
= string
;
5902 it
->bidi_it
.string
.s
= NULL
;
5903 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5904 it
->bidi_it
.string
.bufpos
= 0;
5905 it
->bidi_it
.string
.from_disp_str
= 0;
5906 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5907 bidi_init_it (charpos
, IT_STRING_BYTEPOS (*it
),
5908 FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
5913 it
->s
= (const unsigned char *) s
;
5916 /* Note that we use IT->current.pos, not it->current.string_pos,
5917 for displaying C strings. */
5918 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = -1;
5919 if (it
->multibyte_p
)
5921 it
->current
.pos
= c_string_pos (charpos
, s
, 1);
5922 it
->end_charpos
= it
->string_nchars
= number_of_chars (s
, 1);
5926 IT_CHARPOS (*it
) = IT_BYTEPOS (*it
) = charpos
;
5927 it
->end_charpos
= it
->string_nchars
= strlen (s
);
5932 it
->bidi_it
.string
.lstring
= Qnil
;
5933 it
->bidi_it
.string
.s
= s
;
5934 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5935 it
->bidi_it
.string
.bufpos
= 0;
5936 it
->bidi_it
.string
.from_disp_str
= 0;
5937 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
5938 bidi_init_it (charpos
, IT_BYTEPOS (*it
), FRAME_WINDOW_P (it
->f
),
5941 it
->method
= GET_FROM_C_STRING
;
5944 /* PRECISION > 0 means don't return more than PRECISION characters
5946 if (precision
> 0 && it
->end_charpos
- charpos
> precision
)
5948 it
->end_charpos
= it
->string_nchars
= charpos
+ precision
;
5950 it
->bidi_it
.string
.schars
= it
->end_charpos
;
5953 /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
5954 characters have been returned. FIELD_WIDTH == 0 means don't pad,
5955 FIELD_WIDTH < 0 means infinite field width. This is useful for
5956 padding with `-' at the end of a mode line. */
5957 if (field_width
< 0)
5958 field_width
= INFINITY
;
5959 /* Implementation note: We deliberately don't enlarge
5960 it->bidi_it.string.schars here to fit it->end_charpos, because
5961 the bidi iterator cannot produce characters out of thin air. */
5962 if (field_width
> it
->end_charpos
- charpos
)
5963 it
->end_charpos
= charpos
+ field_width
;
5965 /* Use the standard display table for displaying strings. */
5966 if (DISP_TABLE_P (Vstandard_display_table
))
5967 it
->dp
= XCHAR_TABLE (Vstandard_display_table
);
5969 it
->stop_charpos
= charpos
;
5970 it
->prev_stop
= charpos
;
5971 it
->base_level_stop
= 0;
5974 it
->bidi_it
.first_elt
= 1;
5975 it
->bidi_it
.paragraph_dir
= NEUTRAL_DIR
;
5976 it
->bidi_it
.disp_pos
= -1;
5978 if (s
== NULL
&& it
->multibyte_p
)
5980 EMACS_INT endpos
= SCHARS (it
->string
);
5981 if (endpos
> it
->end_charpos
)
5982 endpos
= it
->end_charpos
;
5983 composition_compute_stop_pos (&it
->cmp_it
, charpos
, -1, endpos
,
5991 /***********************************************************************
5993 ***********************************************************************/
5995 /* Map enum it_method value to corresponding next_element_from_* function. */
5997 static int (* get_next_element
[NUM_IT_METHODS
]) (struct it
*it
) =
5999 next_element_from_buffer
,
6000 next_element_from_display_vector
,
6001 next_element_from_string
,
6002 next_element_from_c_string
,
6003 next_element_from_image
,
6004 next_element_from_stretch
6007 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
6010 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
6011 (possibly with the following characters). */
6013 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
6014 ((IT)->cmp_it.id >= 0 \
6015 || ((IT)->cmp_it.stop_pos == (CHARPOS) \
6016 && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
6017 END_CHARPOS, (IT)->w, \
6018 FACE_FROM_ID ((IT)->f, (IT)->face_id), \
6022 /* Lookup the char-table Vglyphless_char_display for character C (-1
6023 if we want information for no-font case), and return the display
6024 method symbol. By side-effect, update it->what and
6025 it->glyphless_method. This function is called from
6026 get_next_display_element for each character element, and from
6027 x_produce_glyphs when no suitable font was found. */
6030 lookup_glyphless_char_display (int c
, struct it
*it
)
6032 Lisp_Object glyphless_method
= Qnil
;
6034 if (CHAR_TABLE_P (Vglyphless_char_display
)
6035 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
)) >= 1)
6039 glyphless_method
= CHAR_TABLE_REF (Vglyphless_char_display
, c
);
6040 if (CONSP (glyphless_method
))
6041 glyphless_method
= FRAME_WINDOW_P (it
->f
)
6042 ? XCAR (glyphless_method
)
6043 : XCDR (glyphless_method
);
6046 glyphless_method
= XCHAR_TABLE (Vglyphless_char_display
)->extras
[0];
6050 if (NILP (glyphless_method
))
6053 /* The default is to display the character by a proper font. */
6055 /* The default for the no-font case is to display an empty box. */
6056 glyphless_method
= Qempty_box
;
6058 if (EQ (glyphless_method
, Qzero_width
))
6061 return glyphless_method
;
6062 /* This method can't be used for the no-font case. */
6063 glyphless_method
= Qempty_box
;
6065 if (EQ (glyphless_method
, Qthin_space
))
6066 it
->glyphless_method
= GLYPHLESS_DISPLAY_THIN_SPACE
;
6067 else if (EQ (glyphless_method
, Qempty_box
))
6068 it
->glyphless_method
= GLYPHLESS_DISPLAY_EMPTY_BOX
;
6069 else if (EQ (glyphless_method
, Qhex_code
))
6070 it
->glyphless_method
= GLYPHLESS_DISPLAY_HEX_CODE
;
6071 else if (STRINGP (glyphless_method
))
6072 it
->glyphless_method
= GLYPHLESS_DISPLAY_ACRONYM
;
6075 /* Invalid value. We use the default method. */
6076 glyphless_method
= Qnil
;
6079 it
->what
= IT_GLYPHLESS
;
6080 return glyphless_method
;
6083 /* Load IT's display element fields with information about the next
6084 display element from the current position of IT. Value is zero if
6085 end of buffer (or C string) is reached. */
6087 static struct frame
*last_escape_glyph_frame
= NULL
;
6088 static unsigned last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
6089 static int last_escape_glyph_merged_face_id
= 0;
6091 struct frame
*last_glyphless_glyph_frame
= NULL
;
6092 unsigned last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
6093 int last_glyphless_glyph_merged_face_id
= 0;
6096 get_next_display_element (struct it
*it
)
6098 /* Non-zero means that we found a display element. Zero means that
6099 we hit the end of what we iterate over. Performance note: the
6100 function pointer `method' used here turns out to be faster than
6101 using a sequence of if-statements. */
6105 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
6107 if (it
->what
== IT_CHARACTER
)
6109 /* UAX#9, L4: "A character is depicted by a mirrored glyph if
6110 and only if (a) the resolved directionality of that character
6112 /* FIXME: Do we need an exception for characters from display
6114 if (it
->bidi_p
&& it
->bidi_it
.type
== STRONG_R
)
6115 it
->c
= bidi_mirror_char (it
->c
);
6116 /* Map via display table or translate control characters.
6117 IT->c, IT->len etc. have been set to the next character by
6118 the function call above. If we have a display table, and it
6119 contains an entry for IT->c, translate it. Don't do this if
6120 IT->c itself comes from a display table, otherwise we could
6121 end up in an infinite recursion. (An alternative could be to
6122 count the recursion depth of this function and signal an
6123 error when a certain maximum depth is reached.) Is it worth
6125 if (success_p
&& it
->dpvec
== NULL
)
6128 struct charset
*unibyte
= CHARSET_FROM_ID (charset_unibyte
);
6129 enum { char_is_other
= 0, char_is_nbsp
, char_is_soft_hyphen
}
6130 nbsp_or_shy
= char_is_other
;
6131 int c
= it
->c
; /* This is the character to display. */
6133 if (! it
->multibyte_p
&& ! ASCII_CHAR_P (c
))
6135 xassert (SINGLE_BYTE_CHAR_P (c
));
6136 if (unibyte_display_via_language_environment
)
6138 c
= DECODE_CHAR (unibyte
, c
);
6140 c
= BYTE8_TO_CHAR (it
->c
);
6143 c
= BYTE8_TO_CHAR (it
->c
);
6147 && (dv
= DISP_CHAR_VECTOR (it
->dp
, c
),
6150 struct Lisp_Vector
*v
= XVECTOR (dv
);
6152 /* Return the first character from the display table
6153 entry, if not empty. If empty, don't display the
6154 current character. */
6157 it
->dpvec_char_len
= it
->len
;
6158 it
->dpvec
= v
->contents
;
6159 it
->dpend
= v
->contents
+ v
->header
.size
;
6160 it
->current
.dpvec_index
= 0;
6161 it
->dpvec_face_id
= -1;
6162 it
->saved_face_id
= it
->face_id
;
6163 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6168 set_iterator_to_next (it
, 0);
6173 if (! NILP (lookup_glyphless_char_display (c
, it
)))
6175 if (it
->what
== IT_GLYPHLESS
)
6177 /* Don't display this character. */
6178 set_iterator_to_next (it
, 0);
6182 if (! ASCII_CHAR_P (c
) && ! NILP (Vnobreak_char_display
))
6183 nbsp_or_shy
= (c
== 0xA0 ? char_is_nbsp
6184 : c
== 0xAD ? char_is_soft_hyphen
6187 /* Translate control characters into `\003' or `^C' form.
6188 Control characters coming from a display table entry are
6189 currently not translated because we use IT->dpvec to hold
6190 the translation. This could easily be changed but I
6191 don't believe that it is worth doing.
6193 NBSP and SOFT-HYPEN are property translated too.
6195 Non-printable characters and raw-byte characters are also
6196 translated to octal form. */
6197 if (((c
< ' ' || c
== 127) /* ASCII control chars */
6198 ? (it
->area
!= TEXT_AREA
6199 /* In mode line, treat \n, \t like other crl chars. */
6202 && (it
->glyph_row
->mode_line_p
|| it
->avoid_cursor_p
))
6203 || (c
!= '\n' && c
!= '\t'))
6206 || ! CHAR_PRINTABLE_P (c
))))
6208 /* C is a control character, NBSP, SOFT-HYPEN, raw-byte,
6209 or a non-printable character which must be displayed
6210 either as '\003' or as `^C' where the '\\' and '^'
6211 can be defined in the display table. Fill
6212 IT->ctl_chars with glyphs for what we have to
6213 display. Then, set IT->dpvec to these glyphs. */
6216 int face_id
, lface_id
= 0 ;
6219 /* Handle control characters with ^. */
6221 if (ASCII_CHAR_P (c
) && it
->ctl_arrow_p
)
6225 g
= '^'; /* default glyph for Control */
6226 /* Set IT->ctl_chars[0] to the glyph for `^'. */
6228 && (gc
= DISP_CTRL_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
6229 && GLYPH_CODE_CHAR_VALID_P (gc
))
6231 g
= GLYPH_CODE_CHAR (gc
);
6232 lface_id
= GLYPH_CODE_FACE (gc
);
6236 face_id
= merge_faces (it
->f
, Qt
, lface_id
, it
->face_id
);
6238 else if (it
->f
== last_escape_glyph_frame
6239 && it
->face_id
== last_escape_glyph_face_id
)
6241 face_id
= last_escape_glyph_merged_face_id
;
6245 /* Merge the escape-glyph face into the current face. */
6246 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6248 last_escape_glyph_frame
= it
->f
;
6249 last_escape_glyph_face_id
= it
->face_id
;
6250 last_escape_glyph_merged_face_id
= face_id
;
6253 XSETINT (it
->ctl_chars
[0], g
);
6254 XSETINT (it
->ctl_chars
[1], c
^ 0100);
6256 goto display_control
;
6259 /* Handle non-break space in the mode where it only gets
6262 if (EQ (Vnobreak_char_display
, Qt
)
6263 && nbsp_or_shy
== char_is_nbsp
)
6265 /* Merge the no-break-space face into the current face. */
6266 face_id
= merge_faces (it
->f
, Qnobreak_space
, 0,
6270 XSETINT (it
->ctl_chars
[0], ' ');
6272 goto display_control
;
6275 /* Handle sequences that start with the "escape glyph". */
6277 /* the default escape glyph is \. */
6278 escape_glyph
= '\\';
6281 && (gc
= DISP_ESCAPE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
6282 && GLYPH_CODE_CHAR_VALID_P (gc
))
6284 escape_glyph
= GLYPH_CODE_CHAR (gc
);
6285 lface_id
= GLYPH_CODE_FACE (gc
);
6289 /* The display table specified a face.
6290 Merge it into face_id and also into escape_glyph. */
6291 face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6294 else if (it
->f
== last_escape_glyph_frame
6295 && it
->face_id
== last_escape_glyph_face_id
)
6297 face_id
= last_escape_glyph_merged_face_id
;
6301 /* Merge the escape-glyph face into the current face. */
6302 face_id
= merge_faces (it
->f
, Qescape_glyph
, 0,
6304 last_escape_glyph_frame
= it
->f
;
6305 last_escape_glyph_face_id
= it
->face_id
;
6306 last_escape_glyph_merged_face_id
= face_id
;
6309 /* Handle soft hyphens in the mode where they only get
6312 if (EQ (Vnobreak_char_display
, Qt
)
6313 && nbsp_or_shy
== char_is_soft_hyphen
)
6315 XSETINT (it
->ctl_chars
[0], '-');
6317 goto display_control
;
6320 /* Handle non-break space and soft hyphen
6321 with the escape glyph. */
6325 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6326 c
= (nbsp_or_shy
== char_is_nbsp
? ' ' : '-');
6327 XSETINT (it
->ctl_chars
[1], c
);
6329 goto display_control
;
6336 if (CHAR_BYTE8_P (c
))
6337 /* Display \200 instead of \17777600. */
6338 c
= CHAR_TO_BYTE8 (c
);
6339 len
= sprintf (str
, "%03o", c
);
6341 XSETINT (it
->ctl_chars
[0], escape_glyph
);
6342 for (i
= 0; i
< len
; i
++)
6343 XSETINT (it
->ctl_chars
[i
+ 1], str
[i
]);
6348 /* Set up IT->dpvec and return first character from it. */
6349 it
->dpvec_char_len
= it
->len
;
6350 it
->dpvec
= it
->ctl_chars
;
6351 it
->dpend
= it
->dpvec
+ ctl_len
;
6352 it
->current
.dpvec_index
= 0;
6353 it
->dpvec_face_id
= face_id
;
6354 it
->saved_face_id
= it
->face_id
;
6355 it
->method
= GET_FROM_DISPLAY_VECTOR
;
6359 it
->char_to_display
= c
;
6363 it
->char_to_display
= it
->c
;
6367 /* Adjust face id for a multibyte character. There are no multibyte
6368 character in unibyte text. */
6369 if ((it
->what
== IT_CHARACTER
|| it
->what
== IT_COMPOSITION
)
6372 && FRAME_WINDOW_P (it
->f
))
6374 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
6376 if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
>= 0)
6378 /* Automatic composition with glyph-string. */
6379 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
6381 it
->face_id
= face_for_font (it
->f
, LGSTRING_FONT (gstring
), face
);
6385 EMACS_INT pos
= (it
->s
? -1
6386 : STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
6387 : IT_CHARPOS (*it
));
6389 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
, pos
,
6395 /* Is this character the last one of a run of characters with
6396 box? If yes, set IT->end_of_box_run_p to 1. */
6400 if (it
->method
== GET_FROM_STRING
&& it
->sp
)
6402 int face_id
= underlying_face_id (it
);
6403 struct face
*face
= FACE_FROM_ID (it
->f
, face_id
);
6407 if (face
->box
== FACE_NO_BOX
)
6409 /* If the box comes from face properties in a
6410 display string, check faces in that string. */
6411 int string_face_id
= face_after_it_pos (it
);
6412 it
->end_of_box_run_p
6413 = (FACE_FROM_ID (it
->f
, string_face_id
)->box
6416 /* Otherwise, the box comes from the underlying face.
6417 If this is the last string character displayed, check
6418 the next buffer location. */
6419 else if ((IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
) - 1)
6420 && (it
->current
.overlay_string_index
6421 == it
->n_overlay_strings
- 1))
6425 struct text_pos pos
= it
->current
.pos
;
6426 INC_TEXT_POS (pos
, it
->multibyte_p
);
6428 next_face_id
= face_at_buffer_position
6429 (it
->w
, CHARPOS (pos
), it
->region_beg_charpos
,
6430 it
->region_end_charpos
, &ignore
,
6431 (IT_CHARPOS (*it
) + TEXT_PROP_DISTANCE_LIMIT
), 0,
6433 it
->end_of_box_run_p
6434 = (FACE_FROM_ID (it
->f
, next_face_id
)->box
6441 int face_id
= face_after_it_pos (it
);
6442 it
->end_of_box_run_p
6443 = (face_id
!= it
->face_id
6444 && FACE_FROM_ID (it
->f
, face_id
)->box
== FACE_NO_BOX
);
6448 /* Value is 0 if end of buffer or string reached. */
6453 /* Move IT to the next display element.
6455 RESEAT_P non-zero means if called on a newline in buffer text,
6456 skip to the next visible line start.
6458 Functions get_next_display_element and set_iterator_to_next are
6459 separate because I find this arrangement easier to handle than a
6460 get_next_display_element function that also increments IT's
6461 position. The way it is we can first look at an iterator's current
6462 display element, decide whether it fits on a line, and if it does,
6463 increment the iterator position. The other way around we probably
6464 would either need a flag indicating whether the iterator has to be
6465 incremented the next time, or we would have to implement a
6466 decrement position function which would not be easy to write. */
6469 set_iterator_to_next (struct it
*it
, int reseat_p
)
6471 /* Reset flags indicating start and end of a sequence of characters
6472 with box. Reset them at the start of this function because
6473 moving the iterator to a new position might set them. */
6474 it
->start_of_box_run_p
= it
->end_of_box_run_p
= 0;
6478 case GET_FROM_BUFFER
:
6479 /* The current display element of IT is a character from
6480 current_buffer. Advance in the buffer, and maybe skip over
6481 invisible lines that are so because of selective display. */
6482 if (ITERATOR_AT_END_OF_LINE_P (it
) && reseat_p
)
6483 reseat_at_next_visible_line_start (it
, 0);
6484 else if (it
->cmp_it
.id
>= 0)
6486 /* We are currently getting glyphs from a composition. */
6491 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6492 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6493 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6495 it
->cmp_it
.from
= it
->cmp_it
.to
;
6500 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6502 it
->end_charpos
, Qnil
);
6505 else if (! it
->cmp_it
.reversed_p
)
6507 /* Composition created while scanning forward. */
6508 /* Update IT's char/byte positions to point to the first
6509 character of the next grapheme cluster, or to the
6510 character visually after the current composition. */
6511 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6512 bidi_move_to_visually_next (&it
->bidi_it
);
6513 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6514 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6516 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6518 /* Proceed to the next grapheme cluster. */
6519 it
->cmp_it
.from
= it
->cmp_it
.to
;
6523 /* No more grapheme clusters in this composition.
6524 Find the next stop position. */
6525 EMACS_INT stop
= it
->end_charpos
;
6526 if (it
->bidi_it
.scan_dir
< 0)
6527 /* Now we are scanning backward and don't know
6530 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6531 IT_BYTEPOS (*it
), stop
, Qnil
);
6536 /* Composition created while scanning backward. */
6537 /* Update IT's char/byte positions to point to the last
6538 character of the previous grapheme cluster, or the
6539 character visually after the current composition. */
6540 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6541 bidi_move_to_visually_next (&it
->bidi_it
);
6542 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6543 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6544 if (it
->cmp_it
.from
> 0)
6546 /* Proceed to the previous grapheme cluster. */
6547 it
->cmp_it
.to
= it
->cmp_it
.from
;
6551 /* No more grapheme clusters in this composition.
6552 Find the next stop position. */
6553 EMACS_INT stop
= it
->end_charpos
;
6554 if (it
->bidi_it
.scan_dir
< 0)
6555 /* Now we are scanning backward and don't know
6558 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6559 IT_BYTEPOS (*it
), stop
, Qnil
);
6565 xassert (it
->len
!= 0);
6569 IT_BYTEPOS (*it
) += it
->len
;
6570 IT_CHARPOS (*it
) += 1;
6574 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
6575 /* If this is a new paragraph, determine its base
6576 direction (a.k.a. its base embedding level). */
6577 if (it
->bidi_it
.new_paragraph
)
6578 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
6579 bidi_move_to_visually_next (&it
->bidi_it
);
6580 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6581 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6582 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
6584 /* As the scan direction was changed, we must
6585 re-compute the stop position for composition. */
6586 EMACS_INT stop
= it
->end_charpos
;
6587 if (it
->bidi_it
.scan_dir
< 0)
6589 composition_compute_stop_pos (&it
->cmp_it
, IT_CHARPOS (*it
),
6590 IT_BYTEPOS (*it
), stop
, Qnil
);
6593 xassert (IT_BYTEPOS (*it
) == CHAR_TO_BYTE (IT_CHARPOS (*it
)));
6597 case GET_FROM_C_STRING
:
6598 /* Current display element of IT is from a C string. */
6600 /* If the string position is beyond string's end, it means
6601 next_element_from_c_string is padding the string with
6602 blanks, in which case we bypass the bidi iterator,
6603 because it cannot deal with such virtual characters. */
6604 || IT_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
6606 IT_BYTEPOS (*it
) += it
->len
;
6607 IT_CHARPOS (*it
) += 1;
6611 bidi_move_to_visually_next (&it
->bidi_it
);
6612 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6613 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6617 case GET_FROM_DISPLAY_VECTOR
:
6618 /* Current display element of IT is from a display table entry.
6619 Advance in the display table definition. Reset it to null if
6620 end reached, and continue with characters from buffers/
6622 ++it
->current
.dpvec_index
;
6624 /* Restore face of the iterator to what they were before the
6625 display vector entry (these entries may contain faces). */
6626 it
->face_id
= it
->saved_face_id
;
6628 if (it
->dpvec
+ it
->current
.dpvec_index
== it
->dpend
)
6630 int recheck_faces
= it
->ellipsis_p
;
6633 it
->method
= GET_FROM_C_STRING
;
6634 else if (STRINGP (it
->string
))
6635 it
->method
= GET_FROM_STRING
;
6638 it
->method
= GET_FROM_BUFFER
;
6639 it
->object
= it
->w
->buffer
;
6643 it
->current
.dpvec_index
= -1;
6645 /* Skip over characters which were displayed via IT->dpvec. */
6646 if (it
->dpvec_char_len
< 0)
6647 reseat_at_next_visible_line_start (it
, 1);
6648 else if (it
->dpvec_char_len
> 0)
6650 if (it
->method
== GET_FROM_STRING
6651 && it
->n_overlay_strings
> 0)
6652 it
->ignore_overlay_strings_at_pos_p
= 1;
6653 it
->len
= it
->dpvec_char_len
;
6654 set_iterator_to_next (it
, reseat_p
);
6657 /* Maybe recheck faces after display vector */
6659 it
->stop_charpos
= IT_CHARPOS (*it
);
6663 case GET_FROM_STRING
:
6664 /* Current display element is a character from a Lisp string. */
6665 xassert (it
->s
== NULL
&& STRINGP (it
->string
));
6666 if (it
->cmp_it
.id
>= 0)
6672 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
6673 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
6674 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6675 it
->cmp_it
.from
= it
->cmp_it
.to
;
6679 composition_compute_stop_pos (&it
->cmp_it
,
6680 IT_STRING_CHARPOS (*it
),
6681 IT_STRING_BYTEPOS (*it
),
6682 it
->end_charpos
, it
->string
);
6685 else if (! it
->cmp_it
.reversed_p
)
6687 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6688 bidi_move_to_visually_next (&it
->bidi_it
);
6689 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6690 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6692 if (it
->cmp_it
.to
< it
->cmp_it
.nglyphs
)
6693 it
->cmp_it
.from
= it
->cmp_it
.to
;
6696 EMACS_INT stop
= it
->end_charpos
;
6697 if (it
->bidi_it
.scan_dir
< 0)
6699 composition_compute_stop_pos (&it
->cmp_it
,
6700 IT_STRING_CHARPOS (*it
),
6701 IT_STRING_BYTEPOS (*it
), stop
,
6707 for (i
= 0; i
< it
->cmp_it
.nchars
; i
++)
6708 bidi_move_to_visually_next (&it
->bidi_it
);
6709 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6710 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6711 if (it
->cmp_it
.from
> 0)
6712 it
->cmp_it
.to
= it
->cmp_it
.from
;
6715 EMACS_INT stop
= it
->end_charpos
;
6716 if (it
->bidi_it
.scan_dir
< 0)
6718 composition_compute_stop_pos (&it
->cmp_it
,
6719 IT_STRING_CHARPOS (*it
),
6720 IT_STRING_BYTEPOS (*it
), stop
,
6728 /* If the string position is beyond string's end, it
6729 means next_element_from_string is padding the string
6730 with blanks, in which case we bypass the bidi
6731 iterator, because it cannot deal with such virtual
6733 || IT_STRING_CHARPOS (*it
) >= it
->bidi_it
.string
.schars
)
6735 IT_STRING_BYTEPOS (*it
) += it
->len
;
6736 IT_STRING_CHARPOS (*it
) += 1;
6740 int prev_scan_dir
= it
->bidi_it
.scan_dir
;
6742 bidi_move_to_visually_next (&it
->bidi_it
);
6743 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6744 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6745 if (prev_scan_dir
!= it
->bidi_it
.scan_dir
)
6747 EMACS_INT stop
= it
->end_charpos
;
6749 if (it
->bidi_it
.scan_dir
< 0)
6751 composition_compute_stop_pos (&it
->cmp_it
,
6752 IT_STRING_CHARPOS (*it
),
6753 IT_STRING_BYTEPOS (*it
), stop
,
6759 consider_string_end
:
6761 if (it
->current
.overlay_string_index
>= 0)
6763 /* IT->string is an overlay string. Advance to the
6764 next, if there is one. */
6765 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
6768 next_overlay_string (it
);
6770 setup_for_ellipsis (it
, 0);
6775 /* IT->string is not an overlay string. If we reached
6776 its end, and there is something on IT->stack, proceed
6777 with what is on the stack. This can be either another
6778 string, this time an overlay string, or a buffer. */
6779 if (IT_STRING_CHARPOS (*it
) == SCHARS (it
->string
)
6783 if (it
->method
== GET_FROM_STRING
)
6784 goto consider_string_end
;
6789 case GET_FROM_IMAGE
:
6790 case GET_FROM_STRETCH
:
6791 /* The position etc with which we have to proceed are on
6792 the stack. The position may be at the end of a string,
6793 if the `display' property takes up the whole string. */
6794 xassert (it
->sp
> 0);
6796 if (it
->method
== GET_FROM_STRING
)
6797 goto consider_string_end
;
6801 /* There are no other methods defined, so this should be a bug. */
6805 xassert (it
->method
!= GET_FROM_STRING
6806 || (STRINGP (it
->string
)
6807 && IT_STRING_CHARPOS (*it
) >= 0));
6810 /* Load IT's display element fields with information about the next
6811 display element which comes from a display table entry or from the
6812 result of translating a control character to one of the forms `^C'
6815 IT->dpvec holds the glyphs to return as characters.
6816 IT->saved_face_id holds the face id before the display vector--it
6817 is restored into IT->face_id in set_iterator_to_next. */
6820 next_element_from_display_vector (struct it
*it
)
6825 xassert (it
->dpvec
&& it
->current
.dpvec_index
>= 0);
6827 it
->face_id
= it
->saved_face_id
;
6829 /* KFS: This code used to check ip->dpvec[0] instead of the current element.
6830 That seemed totally bogus - so I changed it... */
6831 gc
= it
->dpvec
[it
->current
.dpvec_index
];
6833 if (GLYPH_CODE_P (gc
) && GLYPH_CODE_CHAR_VALID_P (gc
))
6835 it
->c
= GLYPH_CODE_CHAR (gc
);
6836 it
->len
= CHAR_BYTES (it
->c
);
6838 /* The entry may contain a face id to use. Such a face id is
6839 the id of a Lisp face, not a realized face. A face id of
6840 zero means no face is specified. */
6841 if (it
->dpvec_face_id
>= 0)
6842 it
->face_id
= it
->dpvec_face_id
;
6845 int lface_id
= GLYPH_CODE_FACE (gc
);
6847 it
->face_id
= merge_faces (it
->f
, Qt
, lface_id
,
6852 /* Display table entry is invalid. Return a space. */
6853 it
->c
= ' ', it
->len
= 1;
6855 /* Don't change position and object of the iterator here. They are
6856 still the values of the character that had this display table
6857 entry or was translated, and that's what we want. */
6858 it
->what
= IT_CHARACTER
;
6862 /* Get the first element of string/buffer in the visual order, after
6863 being reseated to a new position in a string or a buffer. */
6865 get_visually_first_element (struct it
*it
)
6867 int string_p
= STRINGP (it
->string
) || it
->s
;
6868 EMACS_INT eob
= (string_p
? it
->bidi_it
.string
.schars
: ZV
);
6869 EMACS_INT bob
= (string_p
? 0 : BEGV
);
6871 if (STRINGP (it
->string
))
6873 it
->bidi_it
.charpos
= IT_STRING_CHARPOS (*it
);
6874 it
->bidi_it
.bytepos
= IT_STRING_BYTEPOS (*it
);
6878 it
->bidi_it
.charpos
= IT_CHARPOS (*it
);
6879 it
->bidi_it
.bytepos
= IT_BYTEPOS (*it
);
6882 if (it
->bidi_it
.charpos
== eob
)
6884 /* Nothing to do, but reset the FIRST_ELT flag, like
6885 bidi_paragraph_init does, because we are not going to
6887 it
->bidi_it
.first_elt
= 0;
6889 else if (it
->bidi_it
.charpos
== bob
6891 /* FIXME: Should support all Unicode line separators. */
6892 && (FETCH_CHAR (it
->bidi_it
.bytepos
- 1) == '\n'
6893 || FETCH_CHAR (it
->bidi_it
.bytepos
) == '\n')))
6895 /* If we are at the beginning of a line/string, we can produce
6896 the next element right away. */
6897 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
6898 bidi_move_to_visually_next (&it
->bidi_it
);
6902 EMACS_INT orig_bytepos
= it
->bidi_it
.bytepos
;
6904 /* We need to prime the bidi iterator starting at the line's or
6905 string's beginning, before we will be able to produce the
6908 it
->bidi_it
.charpos
= it
->bidi_it
.bytepos
= 0;
6911 it
->bidi_it
.charpos
= find_next_newline_no_quit (IT_CHARPOS (*it
),
6913 it
->bidi_it
.bytepos
= CHAR_TO_BYTE (it
->bidi_it
.charpos
);
6915 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 1);
6918 /* Now return to buffer/string position where we were asked
6919 to get the next display element, and produce that. */
6920 bidi_move_to_visually_next (&it
->bidi_it
);
6922 while (it
->bidi_it
.bytepos
!= orig_bytepos
6923 && it
->bidi_it
.charpos
< eob
);
6926 /* Adjust IT's position information to where we ended up. */
6927 if (STRINGP (it
->string
))
6929 IT_STRING_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6930 IT_STRING_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6934 IT_CHARPOS (*it
) = it
->bidi_it
.charpos
;
6935 IT_BYTEPOS (*it
) = it
->bidi_it
.bytepos
;
6938 if (STRINGP (it
->string
) || !it
->s
)
6940 EMACS_INT stop
, charpos
, bytepos
;
6942 if (STRINGP (it
->string
))
6945 stop
= SCHARS (it
->string
);
6946 if (stop
> it
->end_charpos
)
6947 stop
= it
->end_charpos
;
6948 charpos
= IT_STRING_CHARPOS (*it
);
6949 bytepos
= IT_STRING_BYTEPOS (*it
);
6953 stop
= it
->end_charpos
;
6954 charpos
= IT_CHARPOS (*it
);
6955 bytepos
= IT_BYTEPOS (*it
);
6957 if (it
->bidi_it
.scan_dir
< 0)
6959 composition_compute_stop_pos (&it
->cmp_it
, charpos
, bytepos
, stop
,
6964 /* Load IT with the next display element from Lisp string IT->string.
6965 IT->current.string_pos is the current position within the string.
6966 If IT->current.overlay_string_index >= 0, the Lisp string is an
6970 next_element_from_string (struct it
*it
)
6972 struct text_pos position
;
6974 xassert (STRINGP (it
->string
));
6975 xassert (!it
->bidi_p
|| it
->string
== it
->bidi_it
.string
.lstring
);
6976 xassert (IT_STRING_CHARPOS (*it
) >= 0);
6977 position
= it
->current
.string_pos
;
6979 /* With bidi reordering, the character to display might not be the
6980 character at IT_STRING_CHARPOS. BIDI_IT.FIRST_ELT non-zero means
6981 that we were reseat()ed to a new string, whose paragraph
6982 direction is not known. */
6983 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
6985 get_visually_first_element (it
);
6986 SET_TEXT_POS (position
, IT_STRING_CHARPOS (*it
), IT_STRING_BYTEPOS (*it
));
6989 /* Time to check for invisible text? */
6990 if (IT_STRING_CHARPOS (*it
) < it
->end_charpos
)
6992 if (IT_STRING_CHARPOS (*it
) >= it
->stop_charpos
)
6995 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
6996 || IT_STRING_CHARPOS (*it
) == it
->stop_charpos
))
6998 /* With bidi non-linear iteration, we could find
6999 ourselves far beyond the last computed stop_charpos,
7000 with several other stop positions in between that we
7001 missed. Scan them all now, in buffer's logical
7002 order, until we find and handle the last stop_charpos
7003 that precedes our current position. */
7004 handle_stop_backwards (it
, it
->stop_charpos
);
7005 return GET_NEXT_DISPLAY_ELEMENT (it
);
7011 /* Take note of the stop position we just moved
7012 across, for when we will move back across it. */
7013 it
->prev_stop
= it
->stop_charpos
;
7014 /* If we are at base paragraph embedding level, take
7015 note of the last stop position seen at this
7017 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7018 it
->base_level_stop
= it
->stop_charpos
;
7022 /* Since a handler may have changed IT->method, we must
7024 return GET_NEXT_DISPLAY_ELEMENT (it
);
7028 /* If we are before prev_stop, we may have overstepped
7029 on our way backwards a stop_pos, and if so, we need
7030 to handle that stop_pos. */
7031 && IT_STRING_CHARPOS (*it
) < it
->prev_stop
7032 /* We can sometimes back up for reasons that have nothing
7033 to do with bidi reordering. E.g., compositions. The
7034 code below is only needed when we are above the base
7035 embedding level, so test for that explicitly. */
7036 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7038 /* If we lost track of base_level_stop, we have no better
7039 place for handle_stop_backwards to start from than string
7040 beginning. This happens, e.g., when we were reseated to
7041 the previous screenful of text by vertical-motion. */
7042 if (it
->base_level_stop
<= 0
7043 || IT_STRING_CHARPOS (*it
) < it
->base_level_stop
)
7044 it
->base_level_stop
= 0;
7045 handle_stop_backwards (it
, it
->base_level_stop
);
7046 return GET_NEXT_DISPLAY_ELEMENT (it
);
7050 if (it
->current
.overlay_string_index
>= 0)
7052 /* Get the next character from an overlay string. In overlay
7053 strings, There is no field width or padding with spaces to
7055 if (IT_STRING_CHARPOS (*it
) >= SCHARS (it
->string
))
7060 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7061 IT_STRING_BYTEPOS (*it
),
7062 it
->bidi_it
.scan_dir
< 0
7064 : SCHARS (it
->string
))
7065 && next_element_from_composition (it
))
7069 else if (STRING_MULTIBYTE (it
->string
))
7071 const unsigned char *s
= (SDATA (it
->string
)
7072 + IT_STRING_BYTEPOS (*it
));
7073 it
->c
= string_char_and_length (s
, &it
->len
);
7077 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7083 /* Get the next character from a Lisp string that is not an
7084 overlay string. Such strings come from the mode line, for
7085 example. We may have to pad with spaces, or truncate the
7086 string. See also next_element_from_c_string. */
7087 if (IT_STRING_CHARPOS (*it
) >= it
->end_charpos
)
7092 else if (IT_STRING_CHARPOS (*it
) >= it
->string_nchars
)
7094 /* Pad with spaces. */
7095 it
->c
= ' ', it
->len
= 1;
7096 CHARPOS (position
) = BYTEPOS (position
) = -1;
7098 else if (CHAR_COMPOSED_P (it
, IT_STRING_CHARPOS (*it
),
7099 IT_STRING_BYTEPOS (*it
),
7100 it
->bidi_it
.scan_dir
< 0
7102 : it
->string_nchars
)
7103 && next_element_from_composition (it
))
7107 else if (STRING_MULTIBYTE (it
->string
))
7109 const unsigned char *s
= (SDATA (it
->string
)
7110 + IT_STRING_BYTEPOS (*it
));
7111 it
->c
= string_char_and_length (s
, &it
->len
);
7115 it
->c
= SREF (it
->string
, IT_STRING_BYTEPOS (*it
));
7120 /* Record what we have and where it came from. */
7121 it
->what
= IT_CHARACTER
;
7122 it
->object
= it
->string
;
7123 it
->position
= position
;
7128 /* Load IT with next display element from C string IT->s.
7129 IT->string_nchars is the maximum number of characters to return
7130 from the string. IT->end_charpos may be greater than
7131 IT->string_nchars when this function is called, in which case we
7132 may have to return padding spaces. Value is zero if end of string
7133 reached, including padding spaces. */
7136 next_element_from_c_string (struct it
*it
)
7141 xassert (!it
->bidi_p
|| it
->s
== it
->bidi_it
.string
.s
);
7142 it
->what
= IT_CHARACTER
;
7143 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = 0;
7146 /* With bidi reordering, the character to display might not be the
7147 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7148 we were reseated to a new string, whose paragraph direction is
7150 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7151 get_visually_first_element (it
);
7153 /* IT's position can be greater than IT->string_nchars in case a
7154 field width or precision has been specified when the iterator was
7156 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7158 /* End of the game. */
7162 else if (IT_CHARPOS (*it
) >= it
->string_nchars
)
7164 /* Pad with spaces. */
7165 it
->c
= ' ', it
->len
= 1;
7166 BYTEPOS (it
->position
) = CHARPOS (it
->position
) = -1;
7168 else if (it
->multibyte_p
)
7169 it
->c
= string_char_and_length (it
->s
+ IT_BYTEPOS (*it
), &it
->len
);
7171 it
->c
= it
->s
[IT_BYTEPOS (*it
)], it
->len
= 1;
7177 /* Set up IT to return characters from an ellipsis, if appropriate.
7178 The definition of the ellipsis glyphs may come from a display table
7179 entry. This function fills IT with the first glyph from the
7180 ellipsis if an ellipsis is to be displayed. */
7183 next_element_from_ellipsis (struct it
*it
)
7185 if (it
->selective_display_ellipsis_p
)
7186 setup_for_ellipsis (it
, it
->len
);
7189 /* The face at the current position may be different from the
7190 face we find after the invisible text. Remember what it
7191 was in IT->saved_face_id, and signal that it's there by
7192 setting face_before_selective_p. */
7193 it
->saved_face_id
= it
->face_id
;
7194 it
->method
= GET_FROM_BUFFER
;
7195 it
->object
= it
->w
->buffer
;
7196 reseat_at_next_visible_line_start (it
, 1);
7197 it
->face_before_selective_p
= 1;
7200 return GET_NEXT_DISPLAY_ELEMENT (it
);
7204 /* Deliver an image display element. The iterator IT is already
7205 filled with image information (done in handle_display_prop). Value
7210 next_element_from_image (struct it
*it
)
7212 it
->what
= IT_IMAGE
;
7213 it
->ignore_overlay_strings_at_pos_p
= 0;
7218 /* Fill iterator IT with next display element from a stretch glyph
7219 property. IT->object is the value of the text property. Value is
7223 next_element_from_stretch (struct it
*it
)
7225 it
->what
= IT_STRETCH
;
7229 /* Scan backwards from IT's current position until we find a stop
7230 position, or until BEGV. This is called when we find ourself
7231 before both the last known prev_stop and base_level_stop while
7232 reordering bidirectional text. */
7235 compute_stop_pos_backwards (struct it
*it
)
7237 const int SCAN_BACK_LIMIT
= 1000;
7238 struct text_pos pos
;
7239 struct display_pos save_current
= it
->current
;
7240 struct text_pos save_position
= it
->position
;
7241 EMACS_INT charpos
= IT_CHARPOS (*it
);
7242 EMACS_INT where_we_are
= charpos
;
7243 EMACS_INT save_stop_pos
= it
->stop_charpos
;
7244 EMACS_INT save_end_pos
= it
->end_charpos
;
7246 xassert (NILP (it
->string
) && !it
->s
);
7247 xassert (it
->bidi_p
);
7251 it
->end_charpos
= min (charpos
+ 1, ZV
);
7252 charpos
= max (charpos
- SCAN_BACK_LIMIT
, BEGV
);
7253 SET_TEXT_POS (pos
, charpos
, BYTE_TO_CHAR (charpos
));
7254 reseat_1 (it
, pos
, 0);
7255 compute_stop_pos (it
);
7256 /* We must advance forward, right? */
7257 if (it
->stop_charpos
<= charpos
)
7260 while (charpos
> BEGV
&& it
->stop_charpos
>= it
->end_charpos
);
7262 if (it
->stop_charpos
<= where_we_are
)
7263 it
->prev_stop
= it
->stop_charpos
;
7265 it
->prev_stop
= BEGV
;
7267 it
->current
= save_current
;
7268 it
->position
= save_position
;
7269 it
->stop_charpos
= save_stop_pos
;
7270 it
->end_charpos
= save_end_pos
;
7273 /* Scan forward from CHARPOS in the current buffer/string, until we
7274 find a stop position > current IT's position. Then handle the stop
7275 position before that. This is called when we bump into a stop
7276 position while reordering bidirectional text. CHARPOS should be
7277 the last previously processed stop_pos (or BEGV/0, if none were
7278 processed yet) whose position is less that IT's current
7282 handle_stop_backwards (struct it
*it
, EMACS_INT charpos
)
7284 int bufp
= !STRINGP (it
->string
);
7285 EMACS_INT where_we_are
= (bufp
? IT_CHARPOS (*it
) : IT_STRING_CHARPOS (*it
));
7286 struct display_pos save_current
= it
->current
;
7287 struct text_pos save_position
= it
->position
;
7288 struct text_pos pos1
;
7289 EMACS_INT next_stop
;
7291 /* Scan in strict logical order. */
7292 xassert (it
->bidi_p
);
7296 it
->prev_stop
= charpos
;
7299 SET_TEXT_POS (pos1
, charpos
, CHAR_TO_BYTE (charpos
));
7300 reseat_1 (it
, pos1
, 0);
7303 it
->current
.string_pos
= string_pos (charpos
, it
->string
);
7304 compute_stop_pos (it
);
7305 /* We must advance forward, right? */
7306 if (it
->stop_charpos
<= it
->prev_stop
)
7308 charpos
= it
->stop_charpos
;
7310 while (charpos
<= where_we_are
);
7313 it
->current
= save_current
;
7314 it
->position
= save_position
;
7315 next_stop
= it
->stop_charpos
;
7316 it
->stop_charpos
= it
->prev_stop
;
7318 it
->stop_charpos
= next_stop
;
7321 /* Load IT with the next display element from current_buffer. Value
7322 is zero if end of buffer reached. IT->stop_charpos is the next
7323 position at which to stop and check for text properties or buffer
7327 next_element_from_buffer (struct it
*it
)
7331 xassert (IT_CHARPOS (*it
) >= BEGV
);
7332 xassert (NILP (it
->string
) && !it
->s
);
7333 xassert (!it
->bidi_p
7334 || (it
->bidi_it
.string
.lstring
== Qnil
7335 && it
->bidi_it
.string
.s
== NULL
));
7337 /* With bidi reordering, the character to display might not be the
7338 character at IT_CHARPOS. BIDI_IT.FIRST_ELT non-zero means that
7339 we were reseat()ed to a new buffer position, which is potentially
7340 a different paragraph. */
7341 if (it
->bidi_p
&& it
->bidi_it
.first_elt
)
7343 get_visually_first_element (it
);
7344 SET_TEXT_POS (it
->position
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7347 if (IT_CHARPOS (*it
) >= it
->stop_charpos
)
7349 if (IT_CHARPOS (*it
) >= it
->end_charpos
)
7351 int overlay_strings_follow_p
;
7353 /* End of the game, except when overlay strings follow that
7354 haven't been returned yet. */
7355 if (it
->overlay_strings_at_end_processed_p
)
7356 overlay_strings_follow_p
= 0;
7359 it
->overlay_strings_at_end_processed_p
= 1;
7360 overlay_strings_follow_p
= get_overlay_strings (it
, 0);
7363 if (overlay_strings_follow_p
)
7364 success_p
= GET_NEXT_DISPLAY_ELEMENT (it
);
7368 it
->position
= it
->current
.pos
;
7372 else if (!(!it
->bidi_p
7373 || BIDI_AT_BASE_LEVEL (it
->bidi_it
)
7374 || IT_CHARPOS (*it
) == it
->stop_charpos
))
7376 /* With bidi non-linear iteration, we could find ourselves
7377 far beyond the last computed stop_charpos, with several
7378 other stop positions in between that we missed. Scan
7379 them all now, in buffer's logical order, until we find
7380 and handle the last stop_charpos that precedes our
7381 current position. */
7382 handle_stop_backwards (it
, it
->stop_charpos
);
7383 return GET_NEXT_DISPLAY_ELEMENT (it
);
7389 /* Take note of the stop position we just moved across,
7390 for when we will move back across it. */
7391 it
->prev_stop
= it
->stop_charpos
;
7392 /* If we are at base paragraph embedding level, take
7393 note of the last stop position seen at this
7395 if (BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7396 it
->base_level_stop
= it
->stop_charpos
;
7399 return GET_NEXT_DISPLAY_ELEMENT (it
);
7403 /* If we are before prev_stop, we may have overstepped on
7404 our way backwards a stop_pos, and if so, we need to
7405 handle that stop_pos. */
7406 && IT_CHARPOS (*it
) < it
->prev_stop
7407 /* We can sometimes back up for reasons that have nothing
7408 to do with bidi reordering. E.g., compositions. The
7409 code below is only needed when we are above the base
7410 embedding level, so test for that explicitly. */
7411 && !BIDI_AT_BASE_LEVEL (it
->bidi_it
))
7413 if (it
->base_level_stop
<= 0
7414 || IT_CHARPOS (*it
) < it
->base_level_stop
)
7416 /* If we lost track of base_level_stop, we need to find
7417 prev_stop by looking backwards. This happens, e.g., when
7418 we were reseated to the previous screenful of text by
7420 it
->base_level_stop
= BEGV
;
7421 compute_stop_pos_backwards (it
);
7422 handle_stop_backwards (it
, it
->prev_stop
);
7425 handle_stop_backwards (it
, it
->base_level_stop
);
7426 return GET_NEXT_DISPLAY_ELEMENT (it
);
7430 /* No face changes, overlays etc. in sight, so just return a
7431 character from current_buffer. */
7435 /* Maybe run the redisplay end trigger hook. Performance note:
7436 This doesn't seem to cost measurable time. */
7437 if (it
->redisplay_end_trigger_charpos
7439 && IT_CHARPOS (*it
) >= it
->redisplay_end_trigger_charpos
)
7440 run_redisplay_end_trigger_hook (it
);
7442 stop
= it
->bidi_it
.scan_dir
< 0 ? -1 : it
->end_charpos
;
7443 if (CHAR_COMPOSED_P (it
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
),
7445 && next_element_from_composition (it
))
7450 /* Get the next character, maybe multibyte. */
7451 p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
7452 if (it
->multibyte_p
&& !ASCII_BYTE_P (*p
))
7453 it
->c
= STRING_CHAR_AND_LENGTH (p
, it
->len
);
7455 it
->c
= *p
, it
->len
= 1;
7457 /* Record what we have and where it came from. */
7458 it
->what
= IT_CHARACTER
;
7459 it
->object
= it
->w
->buffer
;
7460 it
->position
= it
->current
.pos
;
7462 /* Normally we return the character found above, except when we
7463 really want to return an ellipsis for selective display. */
7468 /* A value of selective > 0 means hide lines indented more
7469 than that number of columns. */
7470 if (it
->selective
> 0
7471 && IT_CHARPOS (*it
) + 1 < ZV
7472 && indented_beyond_p (IT_CHARPOS (*it
) + 1,
7473 IT_BYTEPOS (*it
) + 1,
7474 (double) it
->selective
)) /* iftc */
7476 success_p
= next_element_from_ellipsis (it
);
7477 it
->dpvec_char_len
= -1;
7480 else if (it
->c
== '\r' && it
->selective
== -1)
7482 /* A value of selective == -1 means that everything from the
7483 CR to the end of the line is invisible, with maybe an
7484 ellipsis displayed for it. */
7485 success_p
= next_element_from_ellipsis (it
);
7486 it
->dpvec_char_len
= -1;
7491 /* Value is zero if end of buffer reached. */
7492 xassert (!success_p
|| it
->what
!= IT_CHARACTER
|| it
->len
> 0);
7497 /* Run the redisplay end trigger hook for IT. */
7500 run_redisplay_end_trigger_hook (struct it
*it
)
7502 Lisp_Object args
[3];
7504 /* IT->glyph_row should be non-null, i.e. we should be actually
7505 displaying something, or otherwise we should not run the hook. */
7506 xassert (it
->glyph_row
);
7508 /* Set up hook arguments. */
7509 args
[0] = Qredisplay_end_trigger_functions
;
7510 args
[1] = it
->window
;
7511 XSETINT (args
[2], it
->redisplay_end_trigger_charpos
);
7512 it
->redisplay_end_trigger_charpos
= 0;
7514 /* Since we are *trying* to run these functions, don't try to run
7515 them again, even if they get an error. */
7516 it
->w
->redisplay_end_trigger
= Qnil
;
7517 Frun_hook_with_args (3, args
);
7519 /* Notice if it changed the face of the character we are on. */
7520 handle_face_prop (it
);
7524 /* Deliver a composition display element. Unlike the other
7525 next_element_from_XXX, this function is not registered in the array
7526 get_next_element[]. It is called from next_element_from_buffer and
7527 next_element_from_string when necessary. */
7530 next_element_from_composition (struct it
*it
)
7532 it
->what
= IT_COMPOSITION
;
7533 it
->len
= it
->cmp_it
.nbytes
;
7534 if (STRINGP (it
->string
))
7538 IT_STRING_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7539 IT_STRING_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7542 it
->position
= it
->current
.string_pos
;
7543 it
->object
= it
->string
;
7544 it
->c
= composition_update_it (&it
->cmp_it
, IT_STRING_CHARPOS (*it
),
7545 IT_STRING_BYTEPOS (*it
), it
->string
);
7551 IT_CHARPOS (*it
) += it
->cmp_it
.nchars
;
7552 IT_BYTEPOS (*it
) += it
->cmp_it
.nbytes
;
7555 if (it
->bidi_it
.new_paragraph
)
7556 bidi_paragraph_init (it
->paragraph_embedding
, &it
->bidi_it
, 0);
7557 /* Resync the bidi iterator with IT's new position.
7558 FIXME: this doesn't support bidirectional text. */
7559 while (it
->bidi_it
.charpos
< IT_CHARPOS (*it
))
7560 bidi_move_to_visually_next (&it
->bidi_it
);
7564 it
->position
= it
->current
.pos
;
7565 it
->object
= it
->w
->buffer
;
7566 it
->c
= composition_update_it (&it
->cmp_it
, IT_CHARPOS (*it
),
7567 IT_BYTEPOS (*it
), Qnil
);
7574 /***********************************************************************
7575 Moving an iterator without producing glyphs
7576 ***********************************************************************/
7578 /* Check if iterator is at a position corresponding to a valid buffer
7579 position after some move_it_ call. */
7581 #define IT_POS_VALID_AFTER_MOVE_P(it) \
7582 ((it)->method == GET_FROM_STRING \
7583 ? IT_STRING_CHARPOS (*it) == 0 \
7587 /* Move iterator IT to a specified buffer or X position within one
7588 line on the display without producing glyphs.
7590 OP should be a bit mask including some or all of these bits:
7591 MOVE_TO_X: Stop upon reaching x-position TO_X.
7592 MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
7593 Regardless of OP's value, stop upon reaching the end of the display line.
7595 TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
7596 This means, in particular, that TO_X includes window's horizontal
7599 The return value has several possible values that
7600 say what condition caused the scan to stop:
7602 MOVE_POS_MATCH_OR_ZV
7603 - when TO_POS or ZV was reached.
7606 -when TO_X was reached before TO_POS or ZV were reached.
7609 - when we reached the end of the display area and the line must
7613 - when we reached the end of the display area and the line is
7617 - when we stopped at a line end, i.e. a newline or a CR and selective
7620 static enum move_it_result
7621 move_it_in_display_line_to (struct it
*it
,
7622 EMACS_INT to_charpos
, int to_x
,
7623 enum move_operation_enum op
)
7625 enum move_it_result result
= MOVE_UNDEFINED
;
7626 struct glyph_row
*saved_glyph_row
;
7627 struct it wrap_it
, atpos_it
, atx_it
, ppos_it
;
7628 void *wrap_data
= NULL
, *atpos_data
= NULL
, *atx_data
= NULL
;
7629 void *ppos_data
= NULL
;
7631 enum it_method prev_method
= it
->method
;
7632 EMACS_INT prev_pos
= IT_CHARPOS (*it
);
7633 int saw_smaller_pos
= prev_pos
< to_charpos
;
7635 /* Don't produce glyphs in produce_glyphs. */
7636 saved_glyph_row
= it
->glyph_row
;
7637 it
->glyph_row
= NULL
;
7639 /* Use wrap_it to save a copy of IT wherever a word wrap could
7640 occur. Use atpos_it to save a copy of IT at the desired buffer
7641 position, if found, so that we can scan ahead and check if the
7642 word later overshoots the window edge. Use atx_it similarly, for
7648 /* Use ppos_it under bidi reordering to save a copy of IT for the
7649 position > CHARPOS that is the closest to CHARPOS. We restore
7650 that position in IT when we have scanned the entire display line
7651 without finding a match for CHARPOS and all the character
7652 positions are greater than CHARPOS. */
7655 SAVE_IT (ppos_it
, *it
, ppos_data
);
7656 SET_TEXT_POS (ppos_it
.current
.pos
, ZV
, ZV_BYTE
);
7657 if ((op
& MOVE_TO_POS
) && IT_CHARPOS (*it
) >= to_charpos
)
7658 SAVE_IT (ppos_it
, *it
, ppos_data
);
7661 #define BUFFER_POS_REACHED_P() \
7662 ((op & MOVE_TO_POS) != 0 \
7663 && BUFFERP (it->object) \
7664 && (IT_CHARPOS (*it) == to_charpos \
7665 || (!it->bidi_p && IT_CHARPOS (*it) > to_charpos)) \
7666 && (it->method == GET_FROM_BUFFER \
7667 || (it->method == GET_FROM_DISPLAY_VECTOR \
7668 && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
7670 /* If there's a line-/wrap-prefix, handle it. */
7671 if (it
->hpos
== 0 && it
->method
== GET_FROM_BUFFER
7672 && it
->current_y
< it
->last_visible_y
)
7673 handle_line_prefix (it
);
7675 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7676 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7680 int x
, i
, ascent
= 0, descent
= 0;
7682 /* Utility macro to reset an iterator with x, ascent, and descent. */
7683 #define IT_RESET_X_ASCENT_DESCENT(IT) \
7684 ((IT)->current_x = x, (IT)->max_ascent = ascent, \
7685 (IT)->max_descent = descent)
7687 /* Stop if we move beyond TO_CHARPOS (after an image or a
7688 display string or stretch glyph). */
7689 if ((op
& MOVE_TO_POS
) != 0
7690 && BUFFERP (it
->object
)
7691 && it
->method
== GET_FROM_BUFFER
7692 && ((!it
->bidi_p
&& IT_CHARPOS (*it
) > to_charpos
)
7694 && (prev_method
== GET_FROM_IMAGE
7695 || prev_method
== GET_FROM_STRETCH
7696 || prev_method
== GET_FROM_STRING
)
7697 /* Passed TO_CHARPOS from left to right. */
7698 && ((prev_pos
< to_charpos
7699 && IT_CHARPOS (*it
) > to_charpos
)
7700 /* Passed TO_CHARPOS from right to left. */
7701 || (prev_pos
> to_charpos
7702 && IT_CHARPOS (*it
) < to_charpos
)))))
7704 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7706 result
= MOVE_POS_MATCH_OR_ZV
;
7709 else if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
7710 /* If wrap_it is valid, the current position might be in a
7711 word that is wrapped. So, save the iterator in
7712 atpos_it and continue to see if wrapping happens. */
7713 SAVE_IT (atpos_it
, *it
, atpos_data
);
7716 /* Stop when ZV reached.
7717 We used to stop here when TO_CHARPOS reached as well, but that is
7718 too soon if this glyph does not fit on this line. So we handle it
7719 explicitly below. */
7720 if (!get_next_display_element (it
))
7722 result
= MOVE_POS_MATCH_OR_ZV
;
7726 if (it
->line_wrap
== TRUNCATE
)
7728 if (BUFFER_POS_REACHED_P ())
7730 result
= MOVE_POS_MATCH_OR_ZV
;
7736 if (it
->line_wrap
== WORD_WRAP
)
7738 if (IT_DISPLAYING_WHITESPACE (it
))
7742 /* We have reached a glyph that follows one or more
7743 whitespace characters. If the position is
7744 already found, we are done. */
7745 if (atpos_it
.sp
>= 0)
7747 RESTORE_IT (it
, &atpos_it
, atpos_data
);
7748 result
= MOVE_POS_MATCH_OR_ZV
;
7753 RESTORE_IT (it
, &atx_it
, atx_data
);
7754 result
= MOVE_X_REACHED
;
7757 /* Otherwise, we can wrap here. */
7758 SAVE_IT (wrap_it
, *it
, wrap_data
);
7764 /* Remember the line height for the current line, in case
7765 the next element doesn't fit on the line. */
7766 ascent
= it
->max_ascent
;
7767 descent
= it
->max_descent
;
7769 /* The call to produce_glyphs will get the metrics of the
7770 display element IT is loaded with. Record the x-position
7771 before this display element, in case it doesn't fit on the
7775 PRODUCE_GLYPHS (it
);
7777 if (it
->area
!= TEXT_AREA
)
7779 prev_method
= it
->method
;
7780 if (it
->method
== GET_FROM_BUFFER
)
7781 prev_pos
= IT_CHARPOS (*it
);
7782 set_iterator_to_next (it
, 1);
7783 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7784 SET_TEXT_POS (this_line_min_pos
,
7785 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7787 && (op
& MOVE_TO_POS
)
7788 && IT_CHARPOS (*it
) > to_charpos
7789 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
7790 SAVE_IT (ppos_it
, *it
, ppos_data
);
7794 /* The number of glyphs we get back in IT->nglyphs will normally
7795 be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
7796 character on a terminal frame, or (iii) a line end. For the
7797 second case, IT->nglyphs - 1 padding glyphs will be present.
7798 (On X frames, there is only one glyph produced for a
7799 composite character.)
7801 The behavior implemented below means, for continuation lines,
7802 that as many spaces of a TAB as fit on the current line are
7803 displayed there. For terminal frames, as many glyphs of a
7804 multi-glyph character are displayed in the current line, too.
7805 This is what the old redisplay code did, and we keep it that
7806 way. Under X, the whole shape of a complex character must
7807 fit on the line or it will be completely displayed in the
7810 Note that both for tabs and padding glyphs, all glyphs have
7814 /* More than one glyph or glyph doesn't fit on line. All
7815 glyphs have the same width. */
7816 int single_glyph_width
= it
->pixel_width
/ it
->nglyphs
;
7818 int x_before_this_char
= x
;
7819 int hpos_before_this_char
= it
->hpos
;
7821 for (i
= 0; i
< it
->nglyphs
; ++i
, x
= new_x
)
7823 new_x
= x
+ single_glyph_width
;
7825 /* We want to leave anything reaching TO_X to the caller. */
7826 if ((op
& MOVE_TO_X
) && new_x
> to_x
)
7828 if (BUFFER_POS_REACHED_P ())
7830 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7831 goto buffer_pos_reached
;
7832 if (atpos_it
.sp
< 0)
7834 SAVE_IT (atpos_it
, *it
, atpos_data
);
7835 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
7840 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7843 result
= MOVE_X_REACHED
;
7848 SAVE_IT (atx_it
, *it
, atx_data
);
7849 IT_RESET_X_ASCENT_DESCENT (&atx_it
);
7854 if (/* Lines are continued. */
7855 it
->line_wrap
!= TRUNCATE
7856 && (/* And glyph doesn't fit on the line. */
7857 new_x
> it
->last_visible_x
7858 /* Or it fits exactly and we're on a window
7860 || (new_x
== it
->last_visible_x
7861 && FRAME_WINDOW_P (it
->f
))))
7863 if (/* IT->hpos == 0 means the very first glyph
7864 doesn't fit on the line, e.g. a wide image. */
7866 || (new_x
== it
->last_visible_x
7867 && FRAME_WINDOW_P (it
->f
)))
7870 it
->current_x
= new_x
;
7872 /* The character's last glyph just barely fits
7874 if (i
== it
->nglyphs
- 1)
7876 /* If this is the destination position,
7877 return a position *before* it in this row,
7878 now that we know it fits in this row. */
7879 if (BUFFER_POS_REACHED_P ())
7881 if (it
->line_wrap
!= WORD_WRAP
7884 it
->hpos
= hpos_before_this_char
;
7885 it
->current_x
= x_before_this_char
;
7886 result
= MOVE_POS_MATCH_OR_ZV
;
7889 if (it
->line_wrap
== WORD_WRAP
7892 SAVE_IT (atpos_it
, *it
, atpos_data
);
7893 atpos_it
.current_x
= x_before_this_char
;
7894 atpos_it
.hpos
= hpos_before_this_char
;
7898 prev_method
= it
->method
;
7899 if (it
->method
== GET_FROM_BUFFER
)
7900 prev_pos
= IT_CHARPOS (*it
);
7901 set_iterator_to_next (it
, 1);
7902 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
7903 SET_TEXT_POS (this_line_min_pos
,
7904 IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
7905 /* On graphical terminals, newlines may
7906 "overflow" into the fringe if
7907 overflow-newline-into-fringe is non-nil.
7908 On text-only terminals, newlines may
7909 overflow into the last glyph on the
7911 if (!FRAME_WINDOW_P (it
->f
)
7912 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
7914 if (!get_next_display_element (it
))
7916 result
= MOVE_POS_MATCH_OR_ZV
;
7919 if (BUFFER_POS_REACHED_P ())
7921 if (ITERATOR_AT_END_OF_LINE_P (it
))
7922 result
= MOVE_POS_MATCH_OR_ZV
;
7924 result
= MOVE_LINE_CONTINUED
;
7927 if (ITERATOR_AT_END_OF_LINE_P (it
))
7929 result
= MOVE_NEWLINE_OR_CR
;
7936 IT_RESET_X_ASCENT_DESCENT (it
);
7938 if (wrap_it
.sp
>= 0)
7940 RESTORE_IT (it
, &wrap_it
, wrap_data
);
7945 TRACE_MOVE ((stderr
, "move_it_in: continued at %d\n",
7947 result
= MOVE_LINE_CONTINUED
;
7951 if (BUFFER_POS_REACHED_P ())
7953 if (it
->line_wrap
!= WORD_WRAP
|| wrap_it
.sp
< 0)
7954 goto buffer_pos_reached
;
7955 if (it
->line_wrap
== WORD_WRAP
&& atpos_it
.sp
< 0)
7957 SAVE_IT (atpos_it
, *it
, atpos_data
);
7958 IT_RESET_X_ASCENT_DESCENT (&atpos_it
);
7962 if (new_x
> it
->first_visible_x
)
7964 /* Glyph is visible. Increment number of glyphs that
7965 would be displayed. */
7970 if (result
!= MOVE_UNDEFINED
)
7973 else if (BUFFER_POS_REACHED_P ())
7976 IT_RESET_X_ASCENT_DESCENT (it
);
7977 result
= MOVE_POS_MATCH_OR_ZV
;
7980 else if ((op
& MOVE_TO_X
) && it
->current_x
>= to_x
)
7982 /* Stop when TO_X specified and reached. This check is
7983 necessary here because of lines consisting of a line end,
7984 only. The line end will not produce any glyphs and we
7985 would never get MOVE_X_REACHED. */
7986 xassert (it
->nglyphs
== 0);
7987 result
= MOVE_X_REACHED
;
7991 /* Is this a line end? If yes, we're done. */
7992 if (ITERATOR_AT_END_OF_LINE_P (it
))
7994 /* If we are past TO_CHARPOS, but never saw any character
7995 positions smaller than TO_CHARPOS, return
7996 MOVE_POS_MATCH_OR_ZV, like the unidirectional display
7998 if ((op
& MOVE_TO_POS
) != 0
8000 && IT_CHARPOS (*it
) > to_charpos
)
8002 result
= MOVE_POS_MATCH_OR_ZV
;
8003 if (it
->bidi_p
&& IT_CHARPOS (ppos_it
) < ZV
)
8004 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8007 result
= MOVE_NEWLINE_OR_CR
;
8011 prev_method
= it
->method
;
8012 if (it
->method
== GET_FROM_BUFFER
)
8013 prev_pos
= IT_CHARPOS (*it
);
8014 /* The current display element has been consumed. Advance
8016 set_iterator_to_next (it
, 1);
8017 if (IT_CHARPOS (*it
) < CHARPOS (this_line_min_pos
))
8018 SET_TEXT_POS (this_line_min_pos
, IT_CHARPOS (*it
), IT_BYTEPOS (*it
));
8019 if (IT_CHARPOS (*it
) < to_charpos
)
8020 saw_smaller_pos
= 1;
8022 && (op
& MOVE_TO_POS
)
8023 && IT_CHARPOS (*it
) >= to_charpos
8024 && IT_CHARPOS (*it
) < IT_CHARPOS (ppos_it
))
8025 SAVE_IT (ppos_it
, *it
, ppos_data
);
8027 /* Stop if lines are truncated and IT's current x-position is
8028 past the right edge of the window now. */
8029 if (it
->line_wrap
== TRUNCATE
8030 && it
->current_x
>= it
->last_visible_x
)
8032 if (!FRAME_WINDOW_P (it
->f
)
8033 || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
8037 if ((at_eob_p
= !get_next_display_element (it
))
8038 || BUFFER_POS_REACHED_P ()
8039 /* If we are past TO_CHARPOS, but never saw any
8040 character positions smaller than TO_CHARPOS,
8041 return MOVE_POS_MATCH_OR_ZV, like the
8042 unidirectional display did. */
8043 || ((op
& MOVE_TO_POS
) != 0
8045 && IT_CHARPOS (*it
) > to_charpos
))
8047 result
= MOVE_POS_MATCH_OR_ZV
;
8048 if (it
->bidi_p
&& !at_eob_p
&& IT_CHARPOS (ppos_it
) < ZV
)
8049 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8052 if (ITERATOR_AT_END_OF_LINE_P (it
))
8054 result
= MOVE_NEWLINE_OR_CR
;
8058 else if ((op
& MOVE_TO_POS
) != 0
8060 && IT_CHARPOS (*it
) > to_charpos
)
8062 result
= MOVE_POS_MATCH_OR_ZV
;
8063 if (it
->bidi_p
&& IT_CHARPOS (ppos_it
) < ZV
)
8064 RESTORE_IT (it
, &ppos_it
, ppos_data
);
8067 result
= MOVE_LINE_TRUNCATED
;
8070 #undef IT_RESET_X_ASCENT_DESCENT
8073 #undef BUFFER_POS_REACHED_P
8075 /* If we scanned beyond to_pos and didn't find a point to wrap at,
8076 restore the saved iterator. */
8077 if (atpos_it
.sp
>= 0)
8078 RESTORE_IT (it
, &atpos_it
, atpos_data
);
8079 else if (atx_it
.sp
>= 0)
8080 RESTORE_IT (it
, &atx_it
, atx_data
);
8093 /* Restore the iterator settings altered at the beginning of this
8095 it
->glyph_row
= saved_glyph_row
;
8099 /* For external use. */
8101 move_it_in_display_line (struct it
*it
,
8102 EMACS_INT to_charpos
, int to_x
,
8103 enum move_operation_enum op
)
8105 if (it
->line_wrap
== WORD_WRAP
8106 && (op
& MOVE_TO_X
))
8109 void *save_data
= NULL
;
8112 SAVE_IT (save_it
, *it
, save_data
);
8113 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8114 /* When word-wrap is on, TO_X may lie past the end
8115 of a wrapped line. Then it->current is the
8116 character on the next line, so backtrack to the
8117 space before the wrap point. */
8118 if (skip
== MOVE_LINE_CONTINUED
)
8120 int prev_x
= max (it
->current_x
- 1, 0);
8121 RESTORE_IT (it
, &save_it
, save_data
);
8122 move_it_in_display_line_to
8123 (it
, -1, prev_x
, MOVE_TO_X
);
8129 move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8133 /* Move IT forward until it satisfies one or more of the criteria in
8134 TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
8136 OP is a bit-mask that specifies where to stop, and in particular,
8137 which of those four position arguments makes a difference. See the
8138 description of enum move_operation_enum.
8140 If TO_CHARPOS is in invisible text, e.g. a truncated part of a
8141 screen line, this function will set IT to the next position that is
8142 displayed to the right of TO_CHARPOS on the screen. */
8145 move_it_to (struct it
*it
, EMACS_INT to_charpos
, int to_x
, int to_y
, int to_vpos
, int op
)
8147 enum move_it_result skip
, skip2
= MOVE_X_REACHED
;
8148 int line_height
, line_start_x
= 0, reached
= 0;
8149 void *backup_data
= NULL
;
8153 if (op
& MOVE_TO_VPOS
)
8155 /* If no TO_CHARPOS and no TO_X specified, stop at the
8156 start of the line TO_VPOS. */
8157 if ((op
& (MOVE_TO_X
| MOVE_TO_POS
)) == 0)
8159 if (it
->vpos
== to_vpos
)
8165 skip
= move_it_in_display_line_to (it
, -1, -1, 0);
8169 /* TO_VPOS >= 0 means stop at TO_X in the line at
8170 TO_VPOS, or at TO_POS, whichever comes first. */
8171 if (it
->vpos
== to_vpos
)
8177 skip
= move_it_in_display_line_to (it
, to_charpos
, to_x
, op
);
8179 if (skip
== MOVE_POS_MATCH_OR_ZV
|| it
->vpos
== to_vpos
)
8184 else if (skip
== MOVE_X_REACHED
&& it
->vpos
!= to_vpos
)
8186 /* We have reached TO_X but not in the line we want. */
8187 skip
= move_it_in_display_line_to (it
, to_charpos
,
8189 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8197 else if (op
& MOVE_TO_Y
)
8199 struct it it_backup
;
8201 if (it
->line_wrap
== WORD_WRAP
)
8202 SAVE_IT (it_backup
, *it
, backup_data
);
8204 /* TO_Y specified means stop at TO_X in the line containing
8205 TO_Y---or at TO_CHARPOS if this is reached first. The
8206 problem is that we can't really tell whether the line
8207 contains TO_Y before we have completely scanned it, and
8208 this may skip past TO_X. What we do is to first scan to
8211 If TO_X is not specified, use a TO_X of zero. The reason
8212 is to make the outcome of this function more predictable.
8213 If we didn't use TO_X == 0, we would stop at the end of
8214 the line which is probably not what a caller would expect
8216 skip
= move_it_in_display_line_to
8217 (it
, to_charpos
, ((op
& MOVE_TO_X
) ? to_x
: 0),
8218 (MOVE_TO_X
| (op
& MOVE_TO_POS
)));
8220 /* If TO_CHARPOS is reached or ZV, we don't have to do more. */
8221 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8223 else if (skip
== MOVE_X_REACHED
)
8225 /* If TO_X was reached, we want to know whether TO_Y is
8226 in the line. We know this is the case if the already
8227 scanned glyphs make the line tall enough. Otherwise,
8228 we must check by scanning the rest of the line. */
8229 line_height
= it
->max_ascent
+ it
->max_descent
;
8230 if (to_y
>= it
->current_y
8231 && to_y
< it
->current_y
+ line_height
)
8236 SAVE_IT (it_backup
, *it
, backup_data
);
8237 TRACE_MOVE ((stderr
, "move_it: from %d\n", IT_CHARPOS (*it
)));
8238 skip2
= move_it_in_display_line_to (it
, to_charpos
, -1,
8240 TRACE_MOVE ((stderr
, "move_it: to %d\n", IT_CHARPOS (*it
)));
8241 line_height
= it
->max_ascent
+ it
->max_descent
;
8242 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8244 if (to_y
>= it
->current_y
8245 && to_y
< it
->current_y
+ line_height
)
8247 /* If TO_Y is in this line and TO_X was reached
8248 above, we scanned too far. We have to restore
8249 IT's settings to the ones before skipping. */
8250 RESTORE_IT (it
, &it_backup
, backup_data
);
8256 if (skip
== MOVE_POS_MATCH_OR_ZV
)
8262 /* Check whether TO_Y is in this line. */
8263 line_height
= it
->max_ascent
+ it
->max_descent
;
8264 TRACE_MOVE ((stderr
, "move_it: line_height = %d\n", line_height
));
8266 if (to_y
>= it
->current_y
8267 && to_y
< it
->current_y
+ line_height
)
8269 /* When word-wrap is on, TO_X may lie past the end
8270 of a wrapped line. Then it->current is the
8271 character on the next line, so backtrack to the
8272 space before the wrap point. */
8273 if (skip
== MOVE_LINE_CONTINUED
8274 && it
->line_wrap
== WORD_WRAP
)
8276 int prev_x
= max (it
->current_x
- 1, 0);
8277 RESTORE_IT (it
, &it_backup
, backup_data
);
8278 skip
= move_it_in_display_line_to
8279 (it
, -1, prev_x
, MOVE_TO_X
);
8288 else if (BUFFERP (it
->object
)
8289 && (it
->method
== GET_FROM_BUFFER
8290 || it
->method
== GET_FROM_STRETCH
)
8291 && IT_CHARPOS (*it
) >= to_charpos
)
8292 skip
= MOVE_POS_MATCH_OR_ZV
;
8294 skip
= move_it_in_display_line_to (it
, to_charpos
, -1, MOVE_TO_POS
);
8298 case MOVE_POS_MATCH_OR_ZV
:
8302 case MOVE_NEWLINE_OR_CR
:
8303 set_iterator_to_next (it
, 1);
8304 it
->continuation_lines_width
= 0;
8307 case MOVE_LINE_TRUNCATED
:
8308 it
->continuation_lines_width
= 0;
8309 reseat_at_next_visible_line_start (it
, 0);
8310 if ((op
& MOVE_TO_POS
) != 0
8311 && IT_CHARPOS (*it
) > to_charpos
)
8318 case MOVE_LINE_CONTINUED
:
8319 /* For continued lines ending in a tab, some of the glyphs
8320 associated with the tab are displayed on the current
8321 line. Since it->current_x does not include these glyphs,
8322 we use it->last_visible_x instead. */
8325 it
->continuation_lines_width
+= it
->last_visible_x
;
8326 /* When moving by vpos, ensure that the iterator really
8327 advances to the next line (bug#847, bug#969). Fixme:
8328 do we need to do this in other circumstances? */
8329 if (it
->current_x
!= it
->last_visible_x
8330 && (op
& MOVE_TO_VPOS
)
8331 && !(op
& (MOVE_TO_X
| MOVE_TO_POS
)))
8333 line_start_x
= it
->current_x
+ it
->pixel_width
8334 - it
->last_visible_x
;
8335 set_iterator_to_next (it
, 0);
8339 it
->continuation_lines_width
+= it
->current_x
;
8346 /* Reset/increment for the next run. */
8347 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
8348 it
->current_x
= line_start_x
;
8351 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8353 last_height
= it
->max_ascent
+ it
->max_descent
;
8354 last_max_ascent
= it
->max_ascent
;
8355 it
->max_ascent
= it
->max_descent
= 0;
8360 /* On text terminals, we may stop at the end of a line in the middle
8361 of a multi-character glyph. If the glyph itself is continued,
8362 i.e. it is actually displayed on the next line, don't treat this
8363 stopping point as valid; move to the next line instead (unless
8364 that brings us offscreen). */
8365 if (!FRAME_WINDOW_P (it
->f
)
8367 && IT_CHARPOS (*it
) == to_charpos
8368 && it
->what
== IT_CHARACTER
8370 && it
->line_wrap
== WINDOW_WRAP
8371 && it
->current_x
== it
->last_visible_x
- 1
8374 && it
->vpos
< XFASTINT (it
->w
->window_end_vpos
))
8376 it
->continuation_lines_width
+= it
->current_x
;
8377 it
->current_x
= it
->hpos
= it
->max_ascent
= it
->max_descent
= 0;
8378 it
->current_y
+= it
->max_ascent
+ it
->max_descent
;
8380 last_height
= it
->max_ascent
+ it
->max_descent
;
8381 last_max_ascent
= it
->max_ascent
;
8385 xfree (backup_data
);
8387 TRACE_MOVE ((stderr
, "move_it_to: reached %d\n", reached
));
8391 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
8393 If DY > 0, move IT backward at least that many pixels. DY = 0
8394 means move IT backward to the preceding line start or BEGV. This
8395 function may move over more than DY pixels if IT->current_y - DY
8396 ends up in the middle of a line; in this case IT->current_y will be
8397 set to the top of the line moved to. */
8400 move_it_vertically_backward (struct it
*it
, int dy
)
8404 void *it2data
= NULL
, *it3data
= NULL
;
8405 EMACS_INT start_pos
;
8410 start_pos
= IT_CHARPOS (*it
);
8412 /* Estimate how many newlines we must move back. */
8413 nlines
= max (1, dy
/ FRAME_LINE_HEIGHT (it
->f
));
8415 /* Set the iterator's position that many lines back. */
8416 while (nlines
-- && IT_CHARPOS (*it
) > BEGV
)
8417 back_to_previous_visible_line_start (it
);
8419 /* Reseat the iterator here. When moving backward, we don't want
8420 reseat to skip forward over invisible text, set up the iterator
8421 to deliver from overlay strings at the new position etc. So,
8422 use reseat_1 here. */
8423 reseat_1 (it
, it
->current
.pos
, 1);
8425 /* We are now surely at a line start. */
8426 it
->current_x
= it
->hpos
= 0;
8427 it
->continuation_lines_width
= 0;
8429 /* Move forward and see what y-distance we moved. First move to the
8430 start of the next line so that we get its height. We need this
8431 height to be able to tell whether we reached the specified
8433 SAVE_IT (it2
, *it
, it2data
);
8434 it2
.max_ascent
= it2
.max_descent
= 0;
8437 move_it_to (&it2
, start_pos
, -1, -1, it2
.vpos
+ 1,
8438 MOVE_TO_POS
| MOVE_TO_VPOS
);
8440 while (!IT_POS_VALID_AFTER_MOVE_P (&it2
));
8441 xassert (IT_CHARPOS (*it
) >= BEGV
);
8442 SAVE_IT (it3
, it2
, it3data
);
8444 move_it_to (&it2
, start_pos
, -1, -1, -1, MOVE_TO_POS
);
8445 xassert (IT_CHARPOS (*it
) >= BEGV
);
8446 /* H is the actual vertical distance from the position in *IT
8447 and the starting position. */
8448 h
= it2
.current_y
- it
->current_y
;
8449 /* NLINES is the distance in number of lines. */
8450 nlines
= it2
.vpos
- it
->vpos
;
8452 /* Correct IT's y and vpos position
8453 so that they are relative to the starting point. */
8459 /* DY == 0 means move to the start of the screen line. The
8460 value of nlines is > 0 if continuation lines were involved. */
8461 RESTORE_IT (it
, it
, it2data
);
8463 move_it_by_lines (it
, nlines
);
8468 /* The y-position we try to reach, relative to *IT.
8469 Note that H has been subtracted in front of the if-statement. */
8470 int target_y
= it
->current_y
+ h
- dy
;
8471 int y0
= it3
.current_y
;
8475 RESTORE_IT (&it3
, &it3
, it3data
);
8476 y1
= line_bottom_y (&it3
);
8477 line_height
= y1
- y0
;
8478 RESTORE_IT (it
, it
, it2data
);
8479 /* If we did not reach target_y, try to move further backward if
8480 we can. If we moved too far backward, try to move forward. */
8481 if (target_y
< it
->current_y
8482 /* This is heuristic. In a window that's 3 lines high, with
8483 a line height of 13 pixels each, recentering with point
8484 on the bottom line will try to move -39/2 = 19 pixels
8485 backward. Try to avoid moving into the first line. */
8486 && (it
->current_y
- target_y
8487 > min (window_box_height (it
->w
), line_height
* 2 / 3))
8488 && IT_CHARPOS (*it
) > BEGV
)
8490 TRACE_MOVE ((stderr
, " not far enough -> move_vert %d\n",
8491 target_y
- it
->current_y
));
8492 dy
= it
->current_y
- target_y
;
8493 goto move_further_back
;
8495 else if (target_y
>= it
->current_y
+ line_height
8496 && IT_CHARPOS (*it
) < ZV
)
8498 /* Should move forward by at least one line, maybe more.
8500 Note: Calling move_it_by_lines can be expensive on
8501 terminal frames, where compute_motion is used (via
8502 vmotion) to do the job, when there are very long lines
8503 and truncate-lines is nil. That's the reason for
8504 treating terminal frames specially here. */
8506 if (!FRAME_WINDOW_P (it
->f
))
8507 move_it_vertically (it
, target_y
- (it
->current_y
+ line_height
));
8512 move_it_by_lines (it
, 1);
8514 while (target_y
>= line_bottom_y (it
) && IT_CHARPOS (*it
) < ZV
);
8521 /* Move IT by a specified amount of pixel lines DY. DY negative means
8522 move backwards. DY = 0 means move to start of screen line. At the
8523 end, IT will be on the start of a screen line. */
8526 move_it_vertically (struct it
*it
, int dy
)
8529 move_it_vertically_backward (it
, -dy
);
8532 TRACE_MOVE ((stderr
, "move_it_v: from %d, %d\n", IT_CHARPOS (*it
), dy
));
8533 move_it_to (it
, ZV
, -1, it
->current_y
+ dy
, -1,
8534 MOVE_TO_POS
| MOVE_TO_Y
);
8535 TRACE_MOVE ((stderr
, "move_it_v: to %d\n", IT_CHARPOS (*it
)));
8537 /* If buffer ends in ZV without a newline, move to the start of
8538 the line to satisfy the post-condition. */
8539 if (IT_CHARPOS (*it
) == ZV
8541 && FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n')
8542 move_it_by_lines (it
, 0);
8547 /* Move iterator IT past the end of the text line it is in. */
8550 move_it_past_eol (struct it
*it
)
8552 enum move_it_result rc
;
8554 rc
= move_it_in_display_line_to (it
, Z
, 0, MOVE_TO_POS
);
8555 if (rc
== MOVE_NEWLINE_OR_CR
)
8556 set_iterator_to_next (it
, 0);
8560 /* Move IT by a specified number DVPOS of screen lines down. DVPOS
8561 negative means move up. DVPOS == 0 means move to the start of the
8564 Optimization idea: If we would know that IT->f doesn't use
8565 a face with proportional font, we could be faster for
8566 truncate-lines nil. */
8569 move_it_by_lines (struct it
*it
, int dvpos
)
8572 /* The commented-out optimization uses vmotion on terminals. This
8573 gives bad results, because elements like it->what, on which
8574 callers such as pos_visible_p rely, aren't updated. */
8575 /* struct position pos;
8576 if (!FRAME_WINDOW_P (it->f))
8578 struct text_pos textpos;
8580 pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
8581 SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
8582 reseat (it, textpos, 1);
8583 it->vpos += pos.vpos;
8584 it->current_y += pos.vpos;
8590 /* DVPOS == 0 means move to the start of the screen line. */
8591 move_it_vertically_backward (it
, 0);
8592 xassert (it
->current_x
== 0 && it
->hpos
== 0);
8593 /* Let next call to line_bottom_y calculate real line height */
8598 move_it_to (it
, -1, -1, -1, it
->vpos
+ dvpos
, MOVE_TO_VPOS
);
8599 if (!IT_POS_VALID_AFTER_MOVE_P (it
))
8600 move_it_to (it
, IT_CHARPOS (*it
) + 1, -1, -1, -1, MOVE_TO_POS
);
8605 void *it2data
= NULL
;
8606 EMACS_INT start_charpos
, i
;
8608 /* Start at the beginning of the screen line containing IT's
8609 position. This may actually move vertically backwards,
8610 in case of overlays, so adjust dvpos accordingly. */
8612 move_it_vertically_backward (it
, 0);
8615 /* Go back -DVPOS visible lines and reseat the iterator there. */
8616 start_charpos
= IT_CHARPOS (*it
);
8617 for (i
= -dvpos
; i
> 0 && IT_CHARPOS (*it
) > BEGV
; --i
)
8618 back_to_previous_visible_line_start (it
);
8619 reseat (it
, it
->current
.pos
, 1);
8621 /* Move further back if we end up in a string or an image. */
8622 while (!IT_POS_VALID_AFTER_MOVE_P (it
))
8624 /* First try to move to start of display line. */
8626 move_it_vertically_backward (it
, 0);
8628 if (IT_POS_VALID_AFTER_MOVE_P (it
))
8630 /* If start of line is still in string or image,
8631 move further back. */
8632 back_to_previous_visible_line_start (it
);
8633 reseat (it
, it
->current
.pos
, 1);
8637 it
->current_x
= it
->hpos
= 0;
8639 /* Above call may have moved too far if continuation lines
8640 are involved. Scan forward and see if it did. */
8641 SAVE_IT (it2
, *it
, it2data
);
8642 it2
.vpos
= it2
.current_y
= 0;
8643 move_it_to (&it2
, start_charpos
, -1, -1, -1, MOVE_TO_POS
);
8644 it
->vpos
-= it2
.vpos
;
8645 it
->current_y
-= it2
.current_y
;
8646 it
->current_x
= it
->hpos
= 0;
8648 /* If we moved too far back, move IT some lines forward. */
8649 if (it2
.vpos
> -dvpos
)
8651 int delta
= it2
.vpos
+ dvpos
;
8653 RESTORE_IT (&it2
, &it2
, it2data
);
8654 SAVE_IT (it2
, *it
, it2data
);
8655 move_it_to (it
, -1, -1, -1, it
->vpos
+ delta
, MOVE_TO_VPOS
);
8656 /* Move back again if we got too far ahead. */
8657 if (IT_CHARPOS (*it
) >= start_charpos
)
8658 RESTORE_IT (it
, &it2
, it2data
);
8663 RESTORE_IT (it
, it
, it2data
);
8667 /* Return 1 if IT points into the middle of a display vector. */
8670 in_display_vector_p (struct it
*it
)
8672 return (it
->method
== GET_FROM_DISPLAY_VECTOR
8673 && it
->current
.dpvec_index
> 0
8674 && it
->dpvec
+ it
->current
.dpvec_index
!= it
->dpend
);
8678 /***********************************************************************
8680 ***********************************************************************/
8683 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
8687 add_to_log (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
8689 Lisp_Object args
[3];
8690 Lisp_Object msg
, fmt
;
8693 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
8696 /* Do nothing if called asynchronously. Inserting text into
8697 a buffer may call after-change-functions and alike and
8698 that would means running Lisp asynchronously. */
8699 if (handling_signal
)
8703 GCPRO4 (fmt
, msg
, arg1
, arg2
);
8705 args
[0] = fmt
= build_string (format
);
8708 msg
= Fformat (3, args
);
8710 len
= SBYTES (msg
) + 1;
8711 SAFE_ALLOCA (buffer
, char *, len
);
8712 memcpy (buffer
, SDATA (msg
), len
);
8714 message_dolog (buffer
, len
- 1, 1, 0);
8721 /* Output a newline in the *Messages* buffer if "needs" one. */
8724 message_log_maybe_newline (void)
8726 if (message_log_need_newline
)
8727 message_dolog ("", 0, 1, 0);
8731 /* Add a string M of length NBYTES to the message log, optionally
8732 terminated with a newline when NLFLAG is non-zero. MULTIBYTE, if
8733 nonzero, means interpret the contents of M as multibyte. This
8734 function calls low-level routines in order to bypass text property
8735 hooks, etc. which might not be safe to run.
8737 This may GC (insert may run before/after change hooks),
8738 so the buffer M must NOT point to a Lisp string. */
8741 message_dolog (const char *m
, EMACS_INT nbytes
, int nlflag
, int multibyte
)
8743 const unsigned char *msg
= (const unsigned char *) m
;
8745 if (!NILP (Vmemory_full
))
8748 if (!NILP (Vmessage_log_max
))
8750 struct buffer
*oldbuf
;
8751 Lisp_Object oldpoint
, oldbegv
, oldzv
;
8752 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
8753 EMACS_INT point_at_end
= 0;
8754 EMACS_INT zv_at_end
= 0;
8755 Lisp_Object old_deactivate_mark
, tem
;
8756 struct gcpro gcpro1
;
8758 old_deactivate_mark
= Vdeactivate_mark
;
8759 oldbuf
= current_buffer
;
8760 Fset_buffer (Fget_buffer_create (Vmessages_buffer_name
));
8761 BVAR (current_buffer
, undo_list
) = Qt
;
8763 oldpoint
= message_dolog_marker1
;
8764 set_marker_restricted (oldpoint
, make_number (PT
), Qnil
);
8765 oldbegv
= message_dolog_marker2
;
8766 set_marker_restricted (oldbegv
, make_number (BEGV
), Qnil
);
8767 oldzv
= message_dolog_marker3
;
8768 set_marker_restricted (oldzv
, make_number (ZV
), Qnil
);
8769 GCPRO1 (old_deactivate_mark
);
8777 BEGV_BYTE
= BEG_BYTE
;
8780 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
8782 /* Insert the string--maybe converting multibyte to single byte
8783 or vice versa, so that all the text fits the buffer. */
8785 && NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8791 /* Convert a multibyte string to single-byte
8792 for the *Message* buffer. */
8793 for (i
= 0; i
< nbytes
; i
+= char_bytes
)
8795 c
= string_char_and_length (msg
+ i
, &char_bytes
);
8796 work
[0] = (ASCII_CHAR_P (c
)
8798 : multibyte_char_to_unibyte (c
));
8799 insert_1_both (work
, 1, 1, 1, 0, 0);
8802 else if (! multibyte
8803 && ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
8807 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
8808 /* Convert a single-byte string to multibyte
8809 for the *Message* buffer. */
8810 for (i
= 0; i
< nbytes
; i
++)
8813 MAKE_CHAR_MULTIBYTE (c
);
8814 char_bytes
= CHAR_STRING (c
, str
);
8815 insert_1_both ((char *) str
, 1, char_bytes
, 1, 0, 0);
8819 insert_1 (m
, nbytes
, 1, 0, 0);
8823 EMACS_INT this_bol
, this_bol_byte
, prev_bol
, prev_bol_byte
;
8824 unsigned long int dups
;
8825 insert_1 ("\n", 1, 1, 0, 0);
8827 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
, -2, 0);
8829 this_bol_byte
= PT_BYTE
;
8831 /* See if this line duplicates the previous one.
8832 If so, combine duplicates. */
8835 scan_newline (PT
, PT_BYTE
, BEG
, BEG_BYTE
, -2, 0);
8837 prev_bol_byte
= PT_BYTE
;
8839 dups
= message_log_check_duplicate (prev_bol_byte
,
8843 del_range_both (prev_bol
, prev_bol_byte
,
8844 this_bol
, this_bol_byte
, 0);
8850 /* If you change this format, don't forget to also
8851 change message_log_check_duplicate. */
8852 sprintf (dupstr
, " [%lu times]", dups
);
8853 duplen
= strlen (dupstr
);
8854 TEMP_SET_PT_BOTH (Z
- 1, Z_BYTE
- 1);
8855 insert_1 (dupstr
, duplen
, 1, 0, 1);
8860 /* If we have more than the desired maximum number of lines
8861 in the *Messages* buffer now, delete the oldest ones.
8862 This is safe because we don't have undo in this buffer. */
8864 if (NATNUMP (Vmessage_log_max
))
8866 scan_newline (Z
, Z_BYTE
, BEG
, BEG_BYTE
,
8867 -XFASTINT (Vmessage_log_max
) - 1, 0);
8868 del_range_both (BEG
, BEG_BYTE
, PT
, PT_BYTE
, 0);
8871 BEGV
= XMARKER (oldbegv
)->charpos
;
8872 BEGV_BYTE
= marker_byte_position (oldbegv
);
8881 ZV
= XMARKER (oldzv
)->charpos
;
8882 ZV_BYTE
= marker_byte_position (oldzv
);
8886 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
8888 /* We can't do Fgoto_char (oldpoint) because it will run some
8890 TEMP_SET_PT_BOTH (XMARKER (oldpoint
)->charpos
,
8891 XMARKER (oldpoint
)->bytepos
);
8894 unchain_marker (XMARKER (oldpoint
));
8895 unchain_marker (XMARKER (oldbegv
));
8896 unchain_marker (XMARKER (oldzv
));
8898 tem
= Fget_buffer_window (Fcurrent_buffer (), Qt
);
8899 set_buffer_internal (oldbuf
);
8901 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
8902 message_log_need_newline
= !nlflag
;
8903 Vdeactivate_mark
= old_deactivate_mark
;
8908 /* We are at the end of the buffer after just having inserted a newline.
8909 (Note: We depend on the fact we won't be crossing the gap.)
8910 Check to see if the most recent message looks a lot like the previous one.
8911 Return 0 if different, 1 if the new one should just replace it, or a
8912 value N > 1 if we should also append " [N times]". */
8914 static unsigned long int
8915 message_log_check_duplicate (EMACS_INT prev_bol_byte
, EMACS_INT this_bol_byte
)
8918 EMACS_INT len
= Z_BYTE
- 1 - this_bol_byte
;
8920 unsigned char *p1
= BUF_BYTE_ADDRESS (current_buffer
, prev_bol_byte
);
8921 unsigned char *p2
= BUF_BYTE_ADDRESS (current_buffer
, this_bol_byte
);
8923 for (i
= 0; i
< len
; i
++)
8925 if (i
>= 3 && p1
[i
-3] == '.' && p1
[i
-2] == '.' && p1
[i
-1] == '.')
8933 if (*p1
++ == ' ' && *p1
++ == '[')
8936 unsigned long int n
= strtoul ((char *) p1
, &pend
, 10);
8937 if (strncmp (pend
, " times]\n", 8) == 0)
8944 /* Display an echo area message M with a specified length of NBYTES
8945 bytes. The string may include null characters. If M is 0, clear
8946 out any existing message, and let the mini-buffer text show
8949 This may GC, so the buffer M must NOT point to a Lisp string. */
8952 message2 (const char *m
, EMACS_INT nbytes
, int multibyte
)
8954 /* First flush out any partial line written with print. */
8955 message_log_maybe_newline ();
8957 message_dolog (m
, nbytes
, 1, multibyte
);
8958 message2_nolog (m
, nbytes
, multibyte
);
8962 /* The non-logging counterpart of message2. */
8965 message2_nolog (const char *m
, EMACS_INT nbytes
, int multibyte
)
8967 struct frame
*sf
= SELECTED_FRAME ();
8968 message_enable_multibyte
= multibyte
;
8970 if (FRAME_INITIAL_P (sf
))
8972 if (noninteractive_need_newline
)
8973 putc ('\n', stderr
);
8974 noninteractive_need_newline
= 0;
8976 fwrite (m
, nbytes
, 1, stderr
);
8977 if (cursor_in_echo_area
== 0)
8978 fprintf (stderr
, "\n");
8981 /* A null message buffer means that the frame hasn't really been
8982 initialized yet. Error messages get reported properly by
8983 cmd_error, so this must be just an informative message; toss it. */
8984 else if (INTERACTIVE
8985 && sf
->glyphs_initialized_p
8986 && FRAME_MESSAGE_BUF (sf
))
8988 Lisp_Object mini_window
;
8991 /* Get the frame containing the mini-buffer
8992 that the selected frame is using. */
8993 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
8994 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
8996 FRAME_SAMPLE_VISIBILITY (f
);
8997 if (FRAME_VISIBLE_P (sf
)
8998 && ! FRAME_VISIBLE_P (f
))
8999 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window
)));
9003 set_message (m
, Qnil
, nbytes
, multibyte
);
9004 if (minibuffer_auto_raise
)
9005 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
9008 clear_message (1, 1);
9010 do_pending_window_change (0);
9011 echo_area_display (1);
9012 do_pending_window_change (0);
9013 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
9014 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9019 /* Display an echo area message M with a specified length of NBYTES
9020 bytes. The string may include null characters. If M is not a
9021 string, clear out any existing message, and let the mini-buffer
9024 This function cancels echoing. */
9027 message3 (Lisp_Object m
, EMACS_INT nbytes
, int multibyte
)
9029 struct gcpro gcpro1
;
9032 clear_message (1,1);
9035 /* First flush out any partial line written with print. */
9036 message_log_maybe_newline ();
9042 SAFE_ALLOCA (buffer
, char *, nbytes
);
9043 memcpy (buffer
, SDATA (m
), nbytes
);
9044 message_dolog (buffer
, nbytes
, 1, multibyte
);
9047 message3_nolog (m
, nbytes
, multibyte
);
9053 /* The non-logging version of message3.
9054 This does not cancel echoing, because it is used for echoing.
9055 Perhaps we need to make a separate function for echoing
9056 and make this cancel echoing. */
9059 message3_nolog (Lisp_Object m
, EMACS_INT nbytes
, int multibyte
)
9061 struct frame
*sf
= SELECTED_FRAME ();
9062 message_enable_multibyte
= multibyte
;
9064 if (FRAME_INITIAL_P (sf
))
9066 if (noninteractive_need_newline
)
9067 putc ('\n', stderr
);
9068 noninteractive_need_newline
= 0;
9070 fwrite (SDATA (m
), nbytes
, 1, stderr
);
9071 if (cursor_in_echo_area
== 0)
9072 fprintf (stderr
, "\n");
9075 /* A null message buffer means that the frame hasn't really been
9076 initialized yet. Error messages get reported properly by
9077 cmd_error, so this must be just an informative message; toss it. */
9078 else if (INTERACTIVE
9079 && sf
->glyphs_initialized_p
9080 && FRAME_MESSAGE_BUF (sf
))
9082 Lisp_Object mini_window
;
9086 /* Get the frame containing the mini-buffer
9087 that the selected frame is using. */
9088 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9089 frame
= XWINDOW (mini_window
)->frame
;
9092 FRAME_SAMPLE_VISIBILITY (f
);
9093 if (FRAME_VISIBLE_P (sf
)
9094 && !FRAME_VISIBLE_P (f
))
9095 Fmake_frame_visible (frame
);
9097 if (STRINGP (m
) && SCHARS (m
) > 0)
9099 set_message (NULL
, m
, nbytes
, multibyte
);
9100 if (minibuffer_auto_raise
)
9101 Fraise_frame (frame
);
9102 /* Assume we are not echoing.
9103 (If we are, echo_now will override this.) */
9104 echo_message_buffer
= Qnil
;
9107 clear_message (1, 1);
9109 do_pending_window_change (0);
9110 echo_area_display (1);
9111 do_pending_window_change (0);
9112 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
!= 0 && ! gc_in_progress
)
9113 (*FRAME_TERMINAL (f
)->frame_up_to_date_hook
) (f
);
9118 /* Display a null-terminated echo area message M. If M is 0, clear
9119 out any existing message, and let the mini-buffer text show through.
9121 The buffer M must continue to exist until after the echo area gets
9122 cleared or some other message gets displayed there. Do not pass
9123 text that is stored in a Lisp string. Do not pass text in a buffer
9124 that was alloca'd. */
9127 message1 (const char *m
)
9129 message2 (m
, (m
? strlen (m
) : 0), 0);
9133 /* The non-logging counterpart of message1. */
9136 message1_nolog (const char *m
)
9138 message2_nolog (m
, (m
? strlen (m
) : 0), 0);
9141 /* Display a message M which contains a single %s
9142 which gets replaced with STRING. */
9145 message_with_string (const char *m
, Lisp_Object string
, int log
)
9147 CHECK_STRING (string
);
9153 if (noninteractive_need_newline
)
9154 putc ('\n', stderr
);
9155 noninteractive_need_newline
= 0;
9156 fprintf (stderr
, m
, SDATA (string
));
9157 if (!cursor_in_echo_area
)
9158 fprintf (stderr
, "\n");
9162 else if (INTERACTIVE
)
9164 /* The frame whose minibuffer we're going to display the message on.
9165 It may be larger than the selected frame, so we need
9166 to use its buffer, not the selected frame's buffer. */
9167 Lisp_Object mini_window
;
9168 struct frame
*f
, *sf
= SELECTED_FRAME ();
9170 /* Get the frame containing the minibuffer
9171 that the selected frame is using. */
9172 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9173 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9175 /* A null message buffer means that the frame hasn't really been
9176 initialized yet. Error messages get reported properly by
9177 cmd_error, so this must be just an informative message; toss it. */
9178 if (FRAME_MESSAGE_BUF (f
))
9180 Lisp_Object args
[2], msg
;
9181 struct gcpro gcpro1
, gcpro2
;
9183 args
[0] = build_string (m
);
9184 args
[1] = msg
= string
;
9185 GCPRO2 (args
[0], msg
);
9188 msg
= Fformat (2, args
);
9191 message3 (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9193 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9197 /* Print should start at the beginning of the message
9198 buffer next time. */
9199 message_buf_print
= 0;
9205 /* Dump an informative message to the minibuf. If M is 0, clear out
9206 any existing message, and let the mini-buffer text show through. */
9209 vmessage (const char *m
, va_list ap
)
9215 if (noninteractive_need_newline
)
9216 putc ('\n', stderr
);
9217 noninteractive_need_newline
= 0;
9218 vfprintf (stderr
, m
, ap
);
9219 if (cursor_in_echo_area
== 0)
9220 fprintf (stderr
, "\n");
9224 else if (INTERACTIVE
)
9226 /* The frame whose mini-buffer we're going to display the message
9227 on. It may be larger than the selected frame, so we need to
9228 use its buffer, not the selected frame's buffer. */
9229 Lisp_Object mini_window
;
9230 struct frame
*f
, *sf
= SELECTED_FRAME ();
9232 /* Get the frame containing the mini-buffer
9233 that the selected frame is using. */
9234 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9235 f
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
9237 /* A null message buffer means that the frame hasn't really been
9238 initialized yet. Error messages get reported properly by
9239 cmd_error, so this must be just an informative message; toss
9241 if (FRAME_MESSAGE_BUF (f
))
9247 len
= doprnt (FRAME_MESSAGE_BUF (f
),
9248 FRAME_MESSAGE_BUF_SIZE (f
), m
, (char *)0, ap
);
9250 message2 (FRAME_MESSAGE_BUF (f
), len
, 0);
9255 /* Print should start at the beginning of the message
9256 buffer next time. */
9257 message_buf_print
= 0;
9263 message (const char *m
, ...)
9273 /* The non-logging version of message. */
9276 message_nolog (const char *m
, ...)
9278 Lisp_Object old_log_max
;
9281 old_log_max
= Vmessage_log_max
;
9282 Vmessage_log_max
= Qnil
;
9284 Vmessage_log_max
= old_log_max
;
9290 /* Display the current message in the current mini-buffer. This is
9291 only called from error handlers in process.c, and is not time
9295 update_echo_area (void)
9297 if (!NILP (echo_area_buffer
[0]))
9300 string
= Fcurrent_message ();
9301 message3 (string
, SBYTES (string
),
9302 !NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
9307 /* Make sure echo area buffers in `echo_buffers' are live.
9308 If they aren't, make new ones. */
9311 ensure_echo_area_buffers (void)
9315 for (i
= 0; i
< 2; ++i
)
9316 if (!BUFFERP (echo_buffer
[i
])
9317 || NILP (BVAR (XBUFFER (echo_buffer
[i
]), name
)))
9320 Lisp_Object old_buffer
;
9323 old_buffer
= echo_buffer
[i
];
9324 sprintf (name
, " *Echo Area %d*", i
);
9325 echo_buffer
[i
] = Fget_buffer_create (build_string (name
));
9326 BVAR (XBUFFER (echo_buffer
[i
]), truncate_lines
) = Qnil
;
9327 /* to force word wrap in echo area -
9328 it was decided to postpone this*/
9329 /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
9331 for (j
= 0; j
< 2; ++j
)
9332 if (EQ (old_buffer
, echo_area_buffer
[j
]))
9333 echo_area_buffer
[j
] = echo_buffer
[i
];
9338 /* Call FN with args A1..A4 with either the current or last displayed
9339 echo_area_buffer as current buffer.
9341 WHICH zero means use the current message buffer
9342 echo_area_buffer[0]. If that is nil, choose a suitable buffer
9343 from echo_buffer[] and clear it.
9345 WHICH > 0 means use echo_area_buffer[1]. If that is nil, choose a
9346 suitable buffer from echo_buffer[] and clear it.
9348 If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
9349 that the current message becomes the last displayed one, make
9350 choose a suitable buffer for echo_area_buffer[0], and clear it.
9352 Value is what FN returns. */
9355 with_echo_area_buffer (struct window
*w
, int which
,
9356 int (*fn
) (EMACS_INT
, Lisp_Object
, EMACS_INT
, EMACS_INT
),
9357 EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9360 int this_one
, the_other
, clear_buffer_p
, rc
;
9361 int count
= SPECPDL_INDEX ();
9363 /* If buffers aren't live, make new ones. */
9364 ensure_echo_area_buffers ();
9369 this_one
= 0, the_other
= 1;
9371 this_one
= 1, the_other
= 0;
9374 this_one
= 0, the_other
= 1;
9377 /* We need a fresh one in case the current echo buffer equals
9378 the one containing the last displayed echo area message. */
9379 if (!NILP (echo_area_buffer
[this_one
])
9380 && EQ (echo_area_buffer
[this_one
], echo_area_buffer
[the_other
]))
9381 echo_area_buffer
[this_one
] = Qnil
;
9384 /* Choose a suitable buffer from echo_buffer[] is we don't
9386 if (NILP (echo_area_buffer
[this_one
]))
9388 echo_area_buffer
[this_one
]
9389 = (EQ (echo_area_buffer
[the_other
], echo_buffer
[this_one
])
9390 ? echo_buffer
[the_other
]
9391 : echo_buffer
[this_one
]);
9395 buffer
= echo_area_buffer
[this_one
];
9397 /* Don't get confused by reusing the buffer used for echoing
9398 for a different purpose. */
9399 if (echo_kboard
== NULL
&& EQ (buffer
, echo_message_buffer
))
9402 record_unwind_protect (unwind_with_echo_area_buffer
,
9403 with_echo_area_buffer_unwind_data (w
));
9405 /* Make the echo area buffer current. Note that for display
9406 purposes, it is not necessary that the displayed window's buffer
9407 == current_buffer, except for text property lookup. So, let's
9408 only set that buffer temporarily here without doing a full
9409 Fset_window_buffer. We must also change w->pointm, though,
9410 because otherwise an assertions in unshow_buffer fails, and Emacs
9412 set_buffer_internal_1 (XBUFFER (buffer
));
9416 set_marker_both (w
->pointm
, buffer
, BEG
, BEG_BYTE
);
9419 BVAR (current_buffer
, undo_list
) = Qt
;
9420 BVAR (current_buffer
, read_only
) = Qnil
;
9421 specbind (Qinhibit_read_only
, Qt
);
9422 specbind (Qinhibit_modification_hooks
, Qt
);
9424 if (clear_buffer_p
&& Z
> BEG
)
9427 xassert (BEGV
>= BEG
);
9428 xassert (ZV
<= Z
&& ZV
>= BEGV
);
9430 rc
= fn (a1
, a2
, a3
, a4
);
9432 xassert (BEGV
>= BEG
);
9433 xassert (ZV
<= Z
&& ZV
>= BEGV
);
9435 unbind_to (count
, Qnil
);
9440 /* Save state that should be preserved around the call to the function
9441 FN called in with_echo_area_buffer. */
9444 with_echo_area_buffer_unwind_data (struct window
*w
)
9447 Lisp_Object vector
, tmp
;
9449 /* Reduce consing by keeping one vector in
9450 Vwith_echo_area_save_vector. */
9451 vector
= Vwith_echo_area_save_vector
;
9452 Vwith_echo_area_save_vector
= Qnil
;
9455 vector
= Fmake_vector (make_number (7), Qnil
);
9457 XSETBUFFER (tmp
, current_buffer
); ASET (vector
, i
, tmp
); ++i
;
9458 ASET (vector
, i
, Vdeactivate_mark
); ++i
;
9459 ASET (vector
, i
, make_number (windows_or_buffers_changed
)); ++i
;
9463 XSETWINDOW (tmp
, w
); ASET (vector
, i
, tmp
); ++i
;
9464 ASET (vector
, i
, w
->buffer
); ++i
;
9465 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->charpos
)); ++i
;
9466 ASET (vector
, i
, make_number (XMARKER (w
->pointm
)->bytepos
)); ++i
;
9471 for (; i
< end
; ++i
)
9472 ASET (vector
, i
, Qnil
);
9475 xassert (i
== ASIZE (vector
));
9480 /* Restore global state from VECTOR which was created by
9481 with_echo_area_buffer_unwind_data. */
9484 unwind_with_echo_area_buffer (Lisp_Object vector
)
9486 set_buffer_internal_1 (XBUFFER (AREF (vector
, 0)));
9487 Vdeactivate_mark
= AREF (vector
, 1);
9488 windows_or_buffers_changed
= XFASTINT (AREF (vector
, 2));
9490 if (WINDOWP (AREF (vector
, 3)))
9493 Lisp_Object buffer
, charpos
, bytepos
;
9495 w
= XWINDOW (AREF (vector
, 3));
9496 buffer
= AREF (vector
, 4);
9497 charpos
= AREF (vector
, 5);
9498 bytepos
= AREF (vector
, 6);
9501 set_marker_both (w
->pointm
, buffer
,
9502 XFASTINT (charpos
), XFASTINT (bytepos
));
9505 Vwith_echo_area_save_vector
= vector
;
9510 /* Set up the echo area for use by print functions. MULTIBYTE_P
9511 non-zero means we will print multibyte. */
9514 setup_echo_area_for_printing (int multibyte_p
)
9516 /* If we can't find an echo area any more, exit. */
9517 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9520 ensure_echo_area_buffers ();
9522 if (!message_buf_print
)
9524 /* A message has been output since the last time we printed.
9525 Choose a fresh echo area buffer. */
9526 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
9527 echo_area_buffer
[0] = echo_buffer
[1];
9529 echo_area_buffer
[0] = echo_buffer
[0];
9531 /* Switch to that buffer and clear it. */
9532 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
9533 BVAR (current_buffer
, truncate_lines
) = Qnil
;
9537 int count
= SPECPDL_INDEX ();
9538 specbind (Qinhibit_read_only
, Qt
);
9539 /* Note that undo recording is always disabled. */
9541 unbind_to (count
, Qnil
);
9543 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
9545 /* Set up the buffer for the multibyteness we need. */
9547 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
9548 Fset_buffer_multibyte (multibyte_p
? Qt
: Qnil
);
9550 /* Raise the frame containing the echo area. */
9551 if (minibuffer_auto_raise
)
9553 struct frame
*sf
= SELECTED_FRAME ();
9554 Lisp_Object mini_window
;
9555 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
9556 Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window
)));
9559 message_log_maybe_newline ();
9560 message_buf_print
= 1;
9564 if (NILP (echo_area_buffer
[0]))
9566 if (EQ (echo_area_buffer
[1], echo_buffer
[0]))
9567 echo_area_buffer
[0] = echo_buffer
[1];
9569 echo_area_buffer
[0] = echo_buffer
[0];
9572 if (current_buffer
!= XBUFFER (echo_area_buffer
[0]))
9574 /* Someone switched buffers between print requests. */
9575 set_buffer_internal (XBUFFER (echo_area_buffer
[0]));
9576 BVAR (current_buffer
, truncate_lines
) = Qnil
;
9582 /* Display an echo area message in window W. Value is non-zero if W's
9583 height is changed. If display_last_displayed_message_p is
9584 non-zero, display the message that was last displayed, otherwise
9585 display the current message. */
9588 display_echo_area (struct window
*w
)
9590 int i
, no_message_p
, window_height_changed_p
, count
;
9592 /* Temporarily disable garbage collections while displaying the echo
9593 area. This is done because a GC can print a message itself.
9594 That message would modify the echo area buffer's contents while a
9595 redisplay of the buffer is going on, and seriously confuse
9597 count
= inhibit_garbage_collection ();
9599 /* If there is no message, we must call display_echo_area_1
9600 nevertheless because it resizes the window. But we will have to
9601 reset the echo_area_buffer in question to nil at the end because
9602 with_echo_area_buffer will sets it to an empty buffer. */
9603 i
= display_last_displayed_message_p
? 1 : 0;
9604 no_message_p
= NILP (echo_area_buffer
[i
]);
9606 window_height_changed_p
9607 = with_echo_area_buffer (w
, display_last_displayed_message_p
,
9608 display_echo_area_1
,
9609 (intptr_t) w
, Qnil
, 0, 0);
9612 echo_area_buffer
[i
] = Qnil
;
9614 unbind_to (count
, Qnil
);
9615 return window_height_changed_p
;
9619 /* Helper for display_echo_area. Display the current buffer which
9620 contains the current echo area message in window W, a mini-window,
9621 a pointer to which is passed in A1. A2..A4 are currently not used.
9622 Change the height of W so that all of the message is displayed.
9623 Value is non-zero if height of W was changed. */
9626 display_echo_area_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9629 struct window
*w
= (struct window
*) i1
;
9631 struct text_pos start
;
9632 int window_height_changed_p
= 0;
9634 /* Do this before displaying, so that we have a large enough glyph
9635 matrix for the display. If we can't get enough space for the
9636 whole text, display the last N lines. That works by setting w->start. */
9637 window_height_changed_p
= resize_mini_window (w
, 0);
9639 /* Use the starting position chosen by resize_mini_window. */
9640 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
9643 clear_glyph_matrix (w
->desired_matrix
);
9644 XSETWINDOW (window
, w
);
9645 try_window (window
, start
, 0);
9647 return window_height_changed_p
;
9651 /* Resize the echo area window to exactly the size needed for the
9652 currently displayed message, if there is one. If a mini-buffer
9653 is active, don't shrink it. */
9656 resize_echo_area_exactly (void)
9658 if (BUFFERP (echo_area_buffer
[0])
9659 && WINDOWP (echo_area_window
))
9661 struct window
*w
= XWINDOW (echo_area_window
);
9663 Lisp_Object resize_exactly
;
9665 if (minibuf_level
== 0)
9666 resize_exactly
= Qt
;
9668 resize_exactly
= Qnil
;
9670 resized_p
= with_echo_area_buffer (w
, 0, resize_mini_window_1
,
9671 (intptr_t) w
, resize_exactly
,
9675 ++windows_or_buffers_changed
;
9676 ++update_mode_lines
;
9677 redisplay_internal ();
9683 /* Callback function for with_echo_area_buffer, when used from
9684 resize_echo_area_exactly. A1 contains a pointer to the window to
9685 resize, EXACTLY non-nil means resize the mini-window exactly to the
9686 size of the text displayed. A3 and A4 are not used. Value is what
9687 resize_mini_window returns. */
9690 resize_mini_window_1 (EMACS_INT a1
, Lisp_Object exactly
, EMACS_INT a3
, EMACS_INT a4
)
9693 return resize_mini_window ((struct window
*) i1
, !NILP (exactly
));
9697 /* Resize mini-window W to fit the size of its contents. EXACT_P
9698 means size the window exactly to the size needed. Otherwise, it's
9699 only enlarged until W's buffer is empty.
9701 Set W->start to the right place to begin display. If the whole
9702 contents fit, start at the beginning. Otherwise, start so as
9703 to make the end of the contents appear. This is particularly
9704 important for y-or-n-p, but seems desirable generally.
9706 Value is non-zero if the window height has been changed. */
9709 resize_mini_window (struct window
*w
, int exact_p
)
9711 struct frame
*f
= XFRAME (w
->frame
);
9712 int window_height_changed_p
= 0;
9714 xassert (MINI_WINDOW_P (w
));
9716 /* By default, start display at the beginning. */
9717 set_marker_both (w
->start
, w
->buffer
,
9718 BUF_BEGV (XBUFFER (w
->buffer
)),
9719 BUF_BEGV_BYTE (XBUFFER (w
->buffer
)));
9721 /* Don't resize windows while redisplaying a window; it would
9722 confuse redisplay functions when the size of the window they are
9723 displaying changes from under them. Such a resizing can happen,
9724 for instance, when which-func prints a long message while
9725 we are running fontification-functions. We're running these
9726 functions with safe_call which binds inhibit-redisplay to t. */
9727 if (!NILP (Vinhibit_redisplay
))
9730 /* Nil means don't try to resize. */
9731 if (NILP (Vresize_mini_windows
)
9732 || (FRAME_X_P (f
) && FRAME_X_OUTPUT (f
) == NULL
))
9735 if (!FRAME_MINIBUF_ONLY_P (f
))
9738 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
9739 int total_height
= WINDOW_TOTAL_LINES (root
) + WINDOW_TOTAL_LINES (w
);
9740 int height
, max_height
;
9741 int unit
= FRAME_LINE_HEIGHT (f
);
9742 struct text_pos start
;
9743 struct buffer
*old_current_buffer
= NULL
;
9745 if (current_buffer
!= XBUFFER (w
->buffer
))
9747 old_current_buffer
= current_buffer
;
9748 set_buffer_internal (XBUFFER (w
->buffer
));
9751 init_iterator (&it
, w
, BEGV
, BEGV_BYTE
, NULL
, DEFAULT_FACE_ID
);
9753 /* Compute the max. number of lines specified by the user. */
9754 if (FLOATP (Vmax_mini_window_height
))
9755 max_height
= XFLOATINT (Vmax_mini_window_height
) * FRAME_LINES (f
);
9756 else if (INTEGERP (Vmax_mini_window_height
))
9757 max_height
= XINT (Vmax_mini_window_height
);
9759 max_height
= total_height
/ 4;
9761 /* Correct that max. height if it's bogus. */
9762 max_height
= max (1, max_height
);
9763 max_height
= min (total_height
, max_height
);
9765 /* Find out the height of the text in the window. */
9766 if (it
.line_wrap
== TRUNCATE
)
9771 move_it_to (&it
, ZV
, -1, -1, -1, MOVE_TO_POS
);
9772 if (it
.max_ascent
== 0 && it
.max_descent
== 0)
9773 height
= it
.current_y
+ last_height
;
9775 height
= it
.current_y
+ it
.max_ascent
+ it
.max_descent
;
9776 height
-= min (it
.extra_line_spacing
, it
.max_extra_line_spacing
);
9777 height
= (height
+ unit
- 1) / unit
;
9780 /* Compute a suitable window start. */
9781 if (height
> max_height
)
9783 height
= max_height
;
9784 init_iterator (&it
, w
, ZV
, ZV_BYTE
, NULL
, DEFAULT_FACE_ID
);
9785 move_it_vertically_backward (&it
, (height
- 1) * unit
);
9786 start
= it
.current
.pos
;
9789 SET_TEXT_POS (start
, BEGV
, BEGV_BYTE
);
9790 SET_MARKER_FROM_TEXT_POS (w
->start
, start
);
9792 if (EQ (Vresize_mini_windows
, Qgrow_only
))
9794 /* Let it grow only, until we display an empty message, in which
9795 case the window shrinks again. */
9796 if (height
> WINDOW_TOTAL_LINES (w
))
9798 int old_height
= WINDOW_TOTAL_LINES (w
);
9799 freeze_window_starts (f
, 1);
9800 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9801 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9803 else if (height
< WINDOW_TOTAL_LINES (w
)
9804 && (exact_p
|| BEGV
== ZV
))
9806 int old_height
= WINDOW_TOTAL_LINES (w
);
9807 freeze_window_starts (f
, 0);
9808 shrink_mini_window (w
);
9809 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9814 /* Always resize to exact size needed. */
9815 if (height
> WINDOW_TOTAL_LINES (w
))
9817 int old_height
= WINDOW_TOTAL_LINES (w
);
9818 freeze_window_starts (f
, 1);
9819 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9820 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9822 else if (height
< WINDOW_TOTAL_LINES (w
))
9824 int old_height
= WINDOW_TOTAL_LINES (w
);
9825 freeze_window_starts (f
, 0);
9826 shrink_mini_window (w
);
9830 freeze_window_starts (f
, 1);
9831 grow_mini_window (w
, height
- WINDOW_TOTAL_LINES (w
));
9834 window_height_changed_p
= WINDOW_TOTAL_LINES (w
) != old_height
;
9838 if (old_current_buffer
)
9839 set_buffer_internal (old_current_buffer
);
9842 return window_height_changed_p
;
9846 /* Value is the current message, a string, or nil if there is no
9850 current_message (void)
9854 if (!BUFFERP (echo_area_buffer
[0]))
9858 with_echo_area_buffer (0, 0, current_message_1
,
9859 (intptr_t) &msg
, Qnil
, 0, 0);
9861 echo_area_buffer
[0] = Qnil
;
9869 current_message_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9872 Lisp_Object
*msg
= (Lisp_Object
*) i1
;
9875 *msg
= make_buffer_string (BEG
, Z
, 1);
9882 /* Push the current message on Vmessage_stack for later restauration
9883 by restore_message. Value is non-zero if the current message isn't
9884 empty. This is a relatively infrequent operation, so it's not
9885 worth optimizing. */
9891 msg
= current_message ();
9892 Vmessage_stack
= Fcons (msg
, Vmessage_stack
);
9893 return STRINGP (msg
);
9897 /* Restore message display from the top of Vmessage_stack. */
9900 restore_message (void)
9904 xassert (CONSP (Vmessage_stack
));
9905 msg
= XCAR (Vmessage_stack
);
9907 message3_nolog (msg
, SBYTES (msg
), STRING_MULTIBYTE (msg
));
9909 message3_nolog (msg
, 0, 0);
9913 /* Handler for record_unwind_protect calling pop_message. */
9916 pop_message_unwind (Lisp_Object dummy
)
9922 /* Pop the top-most entry off Vmessage_stack. */
9927 xassert (CONSP (Vmessage_stack
));
9928 Vmessage_stack
= XCDR (Vmessage_stack
);
9932 /* Check that Vmessage_stack is nil. Called from emacs.c when Emacs
9933 exits. If the stack is not empty, we have a missing pop_message
9937 check_message_stack (void)
9939 if (!NILP (Vmessage_stack
))
9944 /* Truncate to NCHARS what will be displayed in the echo area the next
9945 time we display it---but don't redisplay it now. */
9948 truncate_echo_area (EMACS_INT nchars
)
9951 echo_area_buffer
[0] = Qnil
;
9952 /* A null message buffer means that the frame hasn't really been
9953 initialized yet. Error messages get reported properly by
9954 cmd_error, so this must be just an informative message; toss it. */
9955 else if (!noninteractive
9957 && !NILP (echo_area_buffer
[0]))
9959 struct frame
*sf
= SELECTED_FRAME ();
9960 if (FRAME_MESSAGE_BUF (sf
))
9961 with_echo_area_buffer (0, 0, truncate_message_1
, nchars
, Qnil
, 0, 0);
9966 /* Helper function for truncate_echo_area. Truncate the current
9967 message to at most NCHARS characters. */
9970 truncate_message_1 (EMACS_INT nchars
, Lisp_Object a2
, EMACS_INT a3
, EMACS_INT a4
)
9972 if (BEG
+ nchars
< Z
)
9973 del_range (BEG
+ nchars
, Z
);
9975 echo_area_buffer
[0] = Qnil
;
9980 /* Set the current message to a substring of S or STRING.
9982 If STRING is a Lisp string, set the message to the first NBYTES
9983 bytes from STRING. NBYTES zero means use the whole string. If
9984 STRING is multibyte, the message will be displayed multibyte.
9986 If S is not null, set the message to the first LEN bytes of S. LEN
9987 zero means use the whole string. MULTIBYTE_P non-zero means S is
9988 multibyte. Display the message multibyte in that case.
9990 Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
9991 to t before calling set_message_1 (which calls insert).
9995 set_message (const char *s
, Lisp_Object string
,
9996 EMACS_INT nbytes
, int multibyte_p
)
9998 message_enable_multibyte
9999 = ((s
&& multibyte_p
)
10000 || (STRINGP (string
) && STRING_MULTIBYTE (string
)));
10002 with_echo_area_buffer (0, -1, set_message_1
,
10003 (intptr_t) s
, string
, nbytes
, multibyte_p
);
10004 message_buf_print
= 0;
10005 help_echo_showing_p
= 0;
10009 /* Helper function for set_message. Arguments have the same meaning
10010 as there, with A1 corresponding to S and A2 corresponding to STRING
10011 This function is called with the echo area buffer being
10015 set_message_1 (EMACS_INT a1
, Lisp_Object a2
, EMACS_INT nbytes
, EMACS_INT multibyte_p
)
10018 const char *s
= (const char *) i1
;
10019 const unsigned char *msg
= (const unsigned char *) s
;
10020 Lisp_Object string
= a2
;
10022 /* Change multibyteness of the echo buffer appropriately. */
10023 if (message_enable_multibyte
10024 != !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10025 Fset_buffer_multibyte (message_enable_multibyte
? Qt
: Qnil
);
10027 BVAR (current_buffer
, truncate_lines
) = message_truncate_lines
? Qt
: Qnil
;
10028 if (!NILP (BVAR (current_buffer
, bidi_display_reordering
)))
10029 BVAR (current_buffer
, bidi_paragraph_direction
) = Qleft_to_right
;
10031 /* Insert new message at BEG. */
10032 TEMP_SET_PT_BOTH (BEG
, BEG_BYTE
);
10034 if (STRINGP (string
))
10039 nbytes
= SBYTES (string
);
10040 nchars
= string_byte_to_char (string
, nbytes
);
10042 /* This function takes care of single/multibyte conversion. We
10043 just have to ensure that the echo area buffer has the right
10044 setting of enable_multibyte_characters. */
10045 insert_from_string (string
, 0, 0, nchars
, nbytes
, 1);
10050 nbytes
= strlen (s
);
10052 if (multibyte_p
&& NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10054 /* Convert from multi-byte to single-byte. */
10059 /* Convert a multibyte string to single-byte. */
10060 for (i
= 0; i
< nbytes
; i
+= n
)
10062 c
= string_char_and_length (msg
+ i
, &n
);
10063 work
[0] = (ASCII_CHAR_P (c
)
10065 : multibyte_char_to_unibyte (c
));
10066 insert_1_both (work
, 1, 1, 1, 0, 0);
10069 else if (!multibyte_p
10070 && !NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
10072 /* Convert from single-byte to multi-byte. */
10075 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
10077 /* Convert a single-byte string to multibyte. */
10078 for (i
= 0; i
< nbytes
; i
++)
10081 MAKE_CHAR_MULTIBYTE (c
);
10082 n
= CHAR_STRING (c
, str
);
10083 insert_1_both ((char *) str
, 1, n
, 1, 0, 0);
10087 insert_1 (s
, nbytes
, 1, 0, 0);
10094 /* Clear messages. CURRENT_P non-zero means clear the current
10095 message. LAST_DISPLAYED_P non-zero means clear the message
10099 clear_message (int current_p
, int last_displayed_p
)
10103 echo_area_buffer
[0] = Qnil
;
10104 message_cleared_p
= 1;
10107 if (last_displayed_p
)
10108 echo_area_buffer
[1] = Qnil
;
10110 message_buf_print
= 0;
10113 /* Clear garbaged frames.
10115 This function is used where the old redisplay called
10116 redraw_garbaged_frames which in turn called redraw_frame which in
10117 turn called clear_frame. The call to clear_frame was a source of
10118 flickering. I believe a clear_frame is not necessary. It should
10119 suffice in the new redisplay to invalidate all current matrices,
10120 and ensure a complete redisplay of all windows. */
10123 clear_garbaged_frames (void)
10125 if (frame_garbaged
)
10127 Lisp_Object tail
, frame
;
10128 int changed_count
= 0;
10130 FOR_EACH_FRAME (tail
, frame
)
10132 struct frame
*f
= XFRAME (frame
);
10134 if (FRAME_VISIBLE_P (f
) && FRAME_GARBAGED_P (f
))
10138 Fredraw_frame (frame
);
10139 f
->force_flush_display_p
= 1;
10141 clear_current_matrices (f
);
10148 frame_garbaged
= 0;
10150 ++windows_or_buffers_changed
;
10155 /* Redisplay the echo area of the selected frame. If UPDATE_FRAME_P
10156 is non-zero update selected_frame. Value is non-zero if the
10157 mini-windows height has been changed. */
10160 echo_area_display (int update_frame_p
)
10162 Lisp_Object mini_window
;
10165 int window_height_changed_p
= 0;
10166 struct frame
*sf
= SELECTED_FRAME ();
10168 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
10169 w
= XWINDOW (mini_window
);
10170 f
= XFRAME (WINDOW_FRAME (w
));
10172 /* Don't display if frame is invisible or not yet initialized. */
10173 if (!FRAME_VISIBLE_P (f
) || !f
->glyphs_initialized_p
)
10176 #ifdef HAVE_WINDOW_SYSTEM
10177 /* When Emacs starts, selected_frame may be the initial terminal
10178 frame. If we let this through, a message would be displayed on
10180 if (FRAME_INITIAL_P (XFRAME (selected_frame
)))
10182 #endif /* HAVE_WINDOW_SYSTEM */
10184 /* Redraw garbaged frames. */
10185 if (frame_garbaged
)
10186 clear_garbaged_frames ();
10188 if (!NILP (echo_area_buffer
[0]) || minibuf_level
== 0)
10190 echo_area_window
= mini_window
;
10191 window_height_changed_p
= display_echo_area (w
);
10192 w
->must_be_updated_p
= 1;
10194 /* Update the display, unless called from redisplay_internal.
10195 Also don't update the screen during redisplay itself. The
10196 update will happen at the end of redisplay, and an update
10197 here could cause confusion. */
10198 if (update_frame_p
&& !redisplaying_p
)
10202 /* If the display update has been interrupted by pending
10203 input, update mode lines in the frame. Due to the
10204 pending input, it might have been that redisplay hasn't
10205 been called, so that mode lines above the echo area are
10206 garbaged. This looks odd, so we prevent it here. */
10207 if (!display_completed
)
10208 n
= redisplay_mode_lines (FRAME_ROOT_WINDOW (f
), 0);
10210 if (window_height_changed_p
10211 /* Don't do this if Emacs is shutting down. Redisplay
10212 needs to run hooks. */
10213 && !NILP (Vrun_hooks
))
10215 /* Must update other windows. Likewise as in other
10216 cases, don't let this update be interrupted by
10218 int count
= SPECPDL_INDEX ();
10219 specbind (Qredisplay_dont_pause
, Qt
);
10220 windows_or_buffers_changed
= 1;
10221 redisplay_internal ();
10222 unbind_to (count
, Qnil
);
10224 else if (FRAME_WINDOW_P (f
) && n
== 0)
10226 /* Window configuration is the same as before.
10227 Can do with a display update of the echo area,
10228 unless we displayed some mode lines. */
10229 update_single_window (w
, 1);
10230 FRAME_RIF (f
)->flush_display (f
);
10233 update_frame (f
, 1, 1);
10235 /* If cursor is in the echo area, make sure that the next
10236 redisplay displays the minibuffer, so that the cursor will
10237 be replaced with what the minibuffer wants. */
10238 if (cursor_in_echo_area
)
10239 ++windows_or_buffers_changed
;
10242 else if (!EQ (mini_window
, selected_window
))
10243 windows_or_buffers_changed
++;
10245 /* Last displayed message is now the current message. */
10246 echo_area_buffer
[1] = echo_area_buffer
[0];
10247 /* Inform read_char that we're not echoing. */
10248 echo_message_buffer
= Qnil
;
10250 /* Prevent redisplay optimization in redisplay_internal by resetting
10251 this_line_start_pos. This is done because the mini-buffer now
10252 displays the message instead of its buffer text. */
10253 if (EQ (mini_window
, selected_window
))
10254 CHARPOS (this_line_start_pos
) = 0;
10256 return window_height_changed_p
;
10261 /***********************************************************************
10262 Mode Lines and Frame Titles
10263 ***********************************************************************/
10265 /* A buffer for constructing non-propertized mode-line strings and
10266 frame titles in it; allocated from the heap in init_xdisp and
10267 resized as needed in store_mode_line_noprop_char. */
10269 static char *mode_line_noprop_buf
;
10271 /* The buffer's end, and a current output position in it. */
10273 static char *mode_line_noprop_buf_end
;
10274 static char *mode_line_noprop_ptr
;
10276 #define MODE_LINE_NOPROP_LEN(start) \
10277 ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
10280 MODE_LINE_DISPLAY
= 0,
10284 } mode_line_target
;
10286 /* Alist that caches the results of :propertize.
10287 Each element is (PROPERTIZED-STRING . PROPERTY-LIST). */
10288 static Lisp_Object mode_line_proptrans_alist
;
10290 /* List of strings making up the mode-line. */
10291 static Lisp_Object mode_line_string_list
;
10293 /* Base face property when building propertized mode line string. */
10294 static Lisp_Object mode_line_string_face
;
10295 static Lisp_Object mode_line_string_face_prop
;
10298 /* Unwind data for mode line strings */
10300 static Lisp_Object Vmode_line_unwind_vector
;
10303 format_mode_line_unwind_data (struct buffer
*obuf
,
10305 int save_proptrans
)
10307 Lisp_Object vector
, tmp
;
10309 /* Reduce consing by keeping one vector in
10310 Vwith_echo_area_save_vector. */
10311 vector
= Vmode_line_unwind_vector
;
10312 Vmode_line_unwind_vector
= Qnil
;
10315 vector
= Fmake_vector (make_number (8), Qnil
);
10317 ASET (vector
, 0, make_number (mode_line_target
));
10318 ASET (vector
, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
10319 ASET (vector
, 2, mode_line_string_list
);
10320 ASET (vector
, 3, save_proptrans
? mode_line_proptrans_alist
: Qt
);
10321 ASET (vector
, 4, mode_line_string_face
);
10322 ASET (vector
, 5, mode_line_string_face_prop
);
10325 XSETBUFFER (tmp
, obuf
);
10328 ASET (vector
, 6, tmp
);
10329 ASET (vector
, 7, owin
);
10335 unwind_format_mode_line (Lisp_Object vector
)
10337 mode_line_target
= XINT (AREF (vector
, 0));
10338 mode_line_noprop_ptr
= mode_line_noprop_buf
+ XINT (AREF (vector
, 1));
10339 mode_line_string_list
= AREF (vector
, 2);
10340 if (! EQ (AREF (vector
, 3), Qt
))
10341 mode_line_proptrans_alist
= AREF (vector
, 3);
10342 mode_line_string_face
= AREF (vector
, 4);
10343 mode_line_string_face_prop
= AREF (vector
, 5);
10345 if (!NILP (AREF (vector
, 7)))
10346 /* Select window before buffer, since it may change the buffer. */
10347 Fselect_window (AREF (vector
, 7), Qt
);
10349 if (!NILP (AREF (vector
, 6)))
10351 set_buffer_internal_1 (XBUFFER (AREF (vector
, 6)));
10352 ASET (vector
, 6, Qnil
);
10355 Vmode_line_unwind_vector
= vector
;
10360 /* Store a single character C for the frame title in mode_line_noprop_buf.
10361 Re-allocate mode_line_noprop_buf if necessary. */
10364 store_mode_line_noprop_char (char c
)
10366 /* If output position has reached the end of the allocated buffer,
10367 double the buffer's size. */
10368 if (mode_line_noprop_ptr
== mode_line_noprop_buf_end
)
10370 int len
= MODE_LINE_NOPROP_LEN (0);
10371 int new_size
= 2 * len
* sizeof *mode_line_noprop_buf
;
10372 mode_line_noprop_buf
= (char *) xrealloc (mode_line_noprop_buf
, new_size
);
10373 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ new_size
;
10374 mode_line_noprop_ptr
= mode_line_noprop_buf
+ len
;
10377 *mode_line_noprop_ptr
++ = c
;
10381 /* Store part of a frame title in mode_line_noprop_buf, beginning at
10382 mode_line_noprop_ptr. STRING is the string to store. Do not copy
10383 characters that yield more columns than PRECISION; PRECISION <= 0
10384 means copy the whole string. Pad with spaces until FIELD_WIDTH
10385 number of characters have been copied; FIELD_WIDTH <= 0 means don't
10386 pad. Called from display_mode_element when it is used to build a
10390 store_mode_line_noprop (const char *string
, int field_width
, int precision
)
10392 const unsigned char *str
= (const unsigned char *) string
;
10394 EMACS_INT dummy
, nbytes
;
10396 /* Copy at most PRECISION chars from STR. */
10397 nbytes
= strlen (string
);
10398 n
+= c_string_width (str
, nbytes
, precision
, &dummy
, &nbytes
);
10400 store_mode_line_noprop_char (*str
++);
10402 /* Fill up with spaces until FIELD_WIDTH reached. */
10403 while (field_width
> 0
10404 && n
< field_width
)
10406 store_mode_line_noprop_char (' ');
10413 /***********************************************************************
10415 ***********************************************************************/
10417 #ifdef HAVE_WINDOW_SYSTEM
10419 /* Set the title of FRAME, if it has changed. The title format is
10420 Vicon_title_format if FRAME is iconified, otherwise it is
10421 frame_title_format. */
10424 x_consider_frame_title (Lisp_Object frame
)
10426 struct frame
*f
= XFRAME (frame
);
10428 if (FRAME_WINDOW_P (f
)
10429 || FRAME_MINIBUF_ONLY_P (f
)
10430 || f
->explicit_name
)
10432 /* Do we have more than one visible frame on this X display? */
10439 int count
= SPECPDL_INDEX ();
10441 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
10443 Lisp_Object other_frame
= XCAR (tail
);
10444 struct frame
*tf
= XFRAME (other_frame
);
10447 && FRAME_KBOARD (tf
) == FRAME_KBOARD (f
)
10448 && !FRAME_MINIBUF_ONLY_P (tf
)
10449 && !EQ (other_frame
, tip_frame
)
10450 && (FRAME_VISIBLE_P (tf
) || FRAME_ICONIFIED_P (tf
)))
10454 /* Set global variable indicating that multiple frames exist. */
10455 multiple_frames
= CONSP (tail
);
10457 /* Switch to the buffer of selected window of the frame. Set up
10458 mode_line_target so that display_mode_element will output into
10459 mode_line_noprop_buf; then display the title. */
10460 record_unwind_protect (unwind_format_mode_line
,
10461 format_mode_line_unwind_data
10462 (current_buffer
, selected_window
, 0));
10464 Fselect_window (f
->selected_window
, Qt
);
10465 set_buffer_internal_1 (XBUFFER (XWINDOW (f
->selected_window
)->buffer
));
10466 fmt
= FRAME_ICONIFIED_P (f
) ? Vicon_title_format
: Vframe_title_format
;
10468 mode_line_target
= MODE_LINE_TITLE
;
10469 title_start
= MODE_LINE_NOPROP_LEN (0);
10470 init_iterator (&it
, XWINDOW (f
->selected_window
), -1, -1,
10471 NULL
, DEFAULT_FACE_ID
);
10472 display_mode_element (&it
, 0, -1, -1, fmt
, Qnil
, 0);
10473 len
= MODE_LINE_NOPROP_LEN (title_start
);
10474 title
= mode_line_noprop_buf
+ title_start
;
10475 unbind_to (count
, Qnil
);
10477 /* Set the title only if it's changed. This avoids consing in
10478 the common case where it hasn't. (If it turns out that we've
10479 already wasted too much time by walking through the list with
10480 display_mode_element, then we might need to optimize at a
10481 higher level than this.) */
10482 if (! STRINGP (f
->name
)
10483 || SBYTES (f
->name
) != len
10484 || memcmp (title
, SDATA (f
->name
), len
) != 0)
10485 x_implicitly_set_name (f
, make_string (title
, len
), Qnil
);
10489 #endif /* not HAVE_WINDOW_SYSTEM */
10494 /***********************************************************************
10496 ***********************************************************************/
10499 /* Prepare for redisplay by updating menu-bar item lists when
10500 appropriate. This can call eval. */
10503 prepare_menu_bars (void)
10506 struct gcpro gcpro1
, gcpro2
;
10508 Lisp_Object tooltip_frame
;
10510 #ifdef HAVE_WINDOW_SYSTEM
10511 tooltip_frame
= tip_frame
;
10513 tooltip_frame
= Qnil
;
10516 /* Update all frame titles based on their buffer names, etc. We do
10517 this before the menu bars so that the buffer-menu will show the
10518 up-to-date frame titles. */
10519 #ifdef HAVE_WINDOW_SYSTEM
10520 if (windows_or_buffers_changed
|| update_mode_lines
)
10522 Lisp_Object tail
, frame
;
10524 FOR_EACH_FRAME (tail
, frame
)
10526 f
= XFRAME (frame
);
10527 if (!EQ (frame
, tooltip_frame
)
10528 && (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
)))
10529 x_consider_frame_title (frame
);
10532 #endif /* HAVE_WINDOW_SYSTEM */
10534 /* Update the menu bar item lists, if appropriate. This has to be
10535 done before any actual redisplay or generation of display lines. */
10536 all_windows
= (update_mode_lines
10537 || buffer_shared
> 1
10538 || windows_or_buffers_changed
);
10541 Lisp_Object tail
, frame
;
10542 int count
= SPECPDL_INDEX ();
10543 /* 1 means that update_menu_bar has run its hooks
10544 so any further calls to update_menu_bar shouldn't do so again. */
10545 int menu_bar_hooks_run
= 0;
10547 record_unwind_save_match_data ();
10549 FOR_EACH_FRAME (tail
, frame
)
10551 f
= XFRAME (frame
);
10553 /* Ignore tooltip frame. */
10554 if (EQ (frame
, tooltip_frame
))
10557 /* If a window on this frame changed size, report that to
10558 the user and clear the size-change flag. */
10559 if (FRAME_WINDOW_SIZES_CHANGED (f
))
10561 Lisp_Object functions
;
10563 /* Clear flag first in case we get an error below. */
10564 FRAME_WINDOW_SIZES_CHANGED (f
) = 0;
10565 functions
= Vwindow_size_change_functions
;
10566 GCPRO2 (tail
, functions
);
10568 while (CONSP (functions
))
10570 if (!EQ (XCAR (functions
), Qt
))
10571 call1 (XCAR (functions
), frame
);
10572 functions
= XCDR (functions
);
10578 menu_bar_hooks_run
= update_menu_bar (f
, 0, menu_bar_hooks_run
);
10579 #ifdef HAVE_WINDOW_SYSTEM
10580 update_tool_bar (f
, 0);
10583 if (windows_or_buffers_changed
10585 ns_set_doc_edited (f
, Fbuffer_modified_p
10586 (XWINDOW (f
->selected_window
)->buffer
));
10591 unbind_to (count
, Qnil
);
10595 struct frame
*sf
= SELECTED_FRAME ();
10596 update_menu_bar (sf
, 1, 0);
10597 #ifdef HAVE_WINDOW_SYSTEM
10598 update_tool_bar (sf
, 1);
10604 /* Update the menu bar item list for frame F. This has to be done
10605 before we start to fill in any display lines, because it can call
10608 If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
10610 If HOOKS_RUN is 1, that means a previous call to update_menu_bar
10611 already ran the menu bar hooks for this redisplay, so there
10612 is no need to run them again. The return value is the
10613 updated value of this flag, to pass to the next call. */
10616 update_menu_bar (struct frame
*f
, int save_match_data
, int hooks_run
)
10618 Lisp_Object window
;
10619 register struct window
*w
;
10621 /* If called recursively during a menu update, do nothing. This can
10622 happen when, for instance, an activate-menubar-hook causes a
10624 if (inhibit_menubar_update
)
10627 window
= FRAME_SELECTED_WINDOW (f
);
10628 w
= XWINDOW (window
);
10630 if (FRAME_WINDOW_P (f
)
10632 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10633 || defined (HAVE_NS) || defined (USE_GTK)
10634 FRAME_EXTERNAL_MENU_BAR (f
)
10636 FRAME_MENU_BAR_LINES (f
) > 0
10638 : FRAME_MENU_BAR_LINES (f
) > 0)
10640 /* If the user has switched buffers or windows, we need to
10641 recompute to reflect the new bindings. But we'll
10642 recompute when update_mode_lines is set too; that means
10643 that people can use force-mode-line-update to request
10644 that the menu bar be recomputed. The adverse effect on
10645 the rest of the redisplay algorithm is about the same as
10646 windows_or_buffers_changed anyway. */
10647 if (windows_or_buffers_changed
10648 /* This used to test w->update_mode_line, but we believe
10649 there is no need to recompute the menu in that case. */
10650 || update_mode_lines
10651 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
10652 < BUF_MODIFF (XBUFFER (w
->buffer
)))
10653 != !NILP (w
->last_had_star
))
10654 || ((!NILP (Vtransient_mark_mode
)
10655 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
10656 != !NILP (w
->region_showing
)))
10658 struct buffer
*prev
= current_buffer
;
10659 int count
= SPECPDL_INDEX ();
10661 specbind (Qinhibit_menubar_update
, Qt
);
10663 set_buffer_internal_1 (XBUFFER (w
->buffer
));
10664 if (save_match_data
)
10665 record_unwind_save_match_data ();
10666 if (NILP (Voverriding_local_map_menu_flag
))
10668 specbind (Qoverriding_terminal_local_map
, Qnil
);
10669 specbind (Qoverriding_local_map
, Qnil
);
10674 /* Run the Lucid hook. */
10675 safe_run_hooks (Qactivate_menubar_hook
);
10677 /* If it has changed current-menubar from previous value,
10678 really recompute the menu-bar from the value. */
10679 if (! NILP (Vlucid_menu_bar_dirty_flag
))
10680 call0 (Qrecompute_lucid_menubar
);
10682 safe_run_hooks (Qmenu_bar_update_hook
);
10687 XSETFRAME (Vmenu_updating_frame
, f
);
10688 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
10690 /* Redisplay the menu bar in case we changed it. */
10691 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10692 || defined (HAVE_NS) || defined (USE_GTK)
10693 if (FRAME_WINDOW_P (f
))
10695 #if defined (HAVE_NS)
10696 /* All frames on Mac OS share the same menubar. So only
10697 the selected frame should be allowed to set it. */
10698 if (f
== SELECTED_FRAME ())
10700 set_frame_menubar (f
, 0, 0);
10703 /* On a terminal screen, the menu bar is an ordinary screen
10704 line, and this makes it get updated. */
10705 w
->update_mode_line
= Qt
;
10706 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
10707 /* In the non-toolkit version, the menu bar is an ordinary screen
10708 line, and this makes it get updated. */
10709 w
->update_mode_line
= Qt
;
10710 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
10712 unbind_to (count
, Qnil
);
10713 set_buffer_internal_1 (prev
);
10722 /***********************************************************************
10724 ***********************************************************************/
10726 #ifdef HAVE_WINDOW_SYSTEM
10729 Nominal cursor position -- where to draw output.
10730 HPOS and VPOS are window relative glyph matrix coordinates.
10731 X and Y are window relative pixel coordinates. */
10733 struct cursor_pos output_cursor
;
10737 Set the global variable output_cursor to CURSOR. All cursor
10738 positions are relative to updated_window. */
10741 set_output_cursor (struct cursor_pos
*cursor
)
10743 output_cursor
.hpos
= cursor
->hpos
;
10744 output_cursor
.vpos
= cursor
->vpos
;
10745 output_cursor
.x
= cursor
->x
;
10746 output_cursor
.y
= cursor
->y
;
10751 Set a nominal cursor position.
10753 HPOS and VPOS are column/row positions in a window glyph matrix. X
10754 and Y are window text area relative pixel positions.
10756 If this is done during an update, updated_window will contain the
10757 window that is being updated and the position is the future output
10758 cursor position for that window. If updated_window is null, use
10759 selected_window and display the cursor at the given position. */
10762 x_cursor_to (int vpos
, int hpos
, int y
, int x
)
10766 /* If updated_window is not set, work on selected_window. */
10767 if (updated_window
)
10768 w
= updated_window
;
10770 w
= XWINDOW (selected_window
);
10772 /* Set the output cursor. */
10773 output_cursor
.hpos
= hpos
;
10774 output_cursor
.vpos
= vpos
;
10775 output_cursor
.x
= x
;
10776 output_cursor
.y
= y
;
10778 /* If not called as part of an update, really display the cursor.
10779 This will also set the cursor position of W. */
10780 if (updated_window
== NULL
)
10783 display_and_set_cursor (w
, 1, hpos
, vpos
, x
, y
);
10784 if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
10785 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
10790 #endif /* HAVE_WINDOW_SYSTEM */
10793 /***********************************************************************
10795 ***********************************************************************/
10797 #ifdef HAVE_WINDOW_SYSTEM
10799 /* Where the mouse was last time we reported a mouse event. */
10801 FRAME_PTR last_mouse_frame
;
10803 /* Tool-bar item index of the item on which a mouse button was pressed
10806 int last_tool_bar_item
;
10810 update_tool_bar_unwind (Lisp_Object frame
)
10812 selected_frame
= frame
;
10816 /* Update the tool-bar item list for frame F. This has to be done
10817 before we start to fill in any display lines. Called from
10818 prepare_menu_bars. If SAVE_MATCH_DATA is non-zero, we must save
10819 and restore it here. */
10822 update_tool_bar (struct frame
*f
, int save_match_data
)
10824 #if defined (USE_GTK) || defined (HAVE_NS)
10825 int do_update
= FRAME_EXTERNAL_TOOL_BAR (f
);
10827 int do_update
= WINDOWP (f
->tool_bar_window
)
10828 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)) > 0;
10833 Lisp_Object window
;
10836 window
= FRAME_SELECTED_WINDOW (f
);
10837 w
= XWINDOW (window
);
10839 /* If the user has switched buffers or windows, we need to
10840 recompute to reflect the new bindings. But we'll
10841 recompute when update_mode_lines is set too; that means
10842 that people can use force-mode-line-update to request
10843 that the menu bar be recomputed. The adverse effect on
10844 the rest of the redisplay algorithm is about the same as
10845 windows_or_buffers_changed anyway. */
10846 if (windows_or_buffers_changed
10847 || !NILP (w
->update_mode_line
)
10848 || update_mode_lines
10849 || ((BUF_SAVE_MODIFF (XBUFFER (w
->buffer
))
10850 < BUF_MODIFF (XBUFFER (w
->buffer
)))
10851 != !NILP (w
->last_had_star
))
10852 || ((!NILP (Vtransient_mark_mode
)
10853 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
10854 != !NILP (w
->region_showing
)))
10856 struct buffer
*prev
= current_buffer
;
10857 int count
= SPECPDL_INDEX ();
10858 Lisp_Object frame
, new_tool_bar
;
10859 int new_n_tool_bar
;
10860 struct gcpro gcpro1
;
10862 /* Set current_buffer to the buffer of the selected
10863 window of the frame, so that we get the right local
10865 set_buffer_internal_1 (XBUFFER (w
->buffer
));
10867 /* Save match data, if we must. */
10868 if (save_match_data
)
10869 record_unwind_save_match_data ();
10871 /* Make sure that we don't accidentally use bogus keymaps. */
10872 if (NILP (Voverriding_local_map_menu_flag
))
10874 specbind (Qoverriding_terminal_local_map
, Qnil
);
10875 specbind (Qoverriding_local_map
, Qnil
);
10878 GCPRO1 (new_tool_bar
);
10880 /* We must temporarily set the selected frame to this frame
10881 before calling tool_bar_items, because the calculation of
10882 the tool-bar keymap uses the selected frame (see
10883 `tool-bar-make-keymap' in tool-bar.el). */
10884 record_unwind_protect (update_tool_bar_unwind
, selected_frame
);
10885 XSETFRAME (frame
, f
);
10886 selected_frame
= frame
;
10888 /* Build desired tool-bar items from keymaps. */
10889 new_tool_bar
= tool_bar_items (Fcopy_sequence (f
->tool_bar_items
),
10892 /* Redisplay the tool-bar if we changed it. */
10893 if (new_n_tool_bar
!= f
->n_tool_bar_items
10894 || NILP (Fequal (new_tool_bar
, f
->tool_bar_items
)))
10896 /* Redisplay that happens asynchronously due to an expose event
10897 may access f->tool_bar_items. Make sure we update both
10898 variables within BLOCK_INPUT so no such event interrupts. */
10900 f
->tool_bar_items
= new_tool_bar
;
10901 f
->n_tool_bar_items
= new_n_tool_bar
;
10902 w
->update_mode_line
= Qt
;
10908 unbind_to (count
, Qnil
);
10909 set_buffer_internal_1 (prev
);
10915 /* Set F->desired_tool_bar_string to a Lisp string representing frame
10916 F's desired tool-bar contents. F->tool_bar_items must have
10917 been set up previously by calling prepare_menu_bars. */
10920 build_desired_tool_bar_string (struct frame
*f
)
10922 int i
, size
, size_needed
;
10923 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10924 Lisp_Object image
, plist
, props
;
10926 image
= plist
= props
= Qnil
;
10927 GCPRO3 (image
, plist
, props
);
10929 /* Prepare F->desired_tool_bar_string. If we can reuse it, do so.
10930 Otherwise, make a new string. */
10932 /* The size of the string we might be able to reuse. */
10933 size
= (STRINGP (f
->desired_tool_bar_string
)
10934 ? SCHARS (f
->desired_tool_bar_string
)
10937 /* We need one space in the string for each image. */
10938 size_needed
= f
->n_tool_bar_items
;
10940 /* Reuse f->desired_tool_bar_string, if possible. */
10941 if (size
< size_needed
|| NILP (f
->desired_tool_bar_string
))
10942 f
->desired_tool_bar_string
= Fmake_string (make_number (size_needed
),
10943 make_number (' '));
10946 props
= list4 (Qdisplay
, Qnil
, Qmenu_item
, Qnil
);
10947 Fremove_text_properties (make_number (0), make_number (size
),
10948 props
, f
->desired_tool_bar_string
);
10951 /* Put a `display' property on the string for the images to display,
10952 put a `menu_item' property on tool-bar items with a value that
10953 is the index of the item in F's tool-bar item vector. */
10954 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
10956 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
10958 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
10959 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
10960 int hmargin
, vmargin
, relief
, idx
, end
;
10962 /* If image is a vector, choose the image according to the
10964 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
10965 if (VECTORP (image
))
10969 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
10970 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
10973 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
10974 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
10976 xassert (ASIZE (image
) >= idx
);
10977 image
= AREF (image
, idx
);
10982 /* Ignore invalid image specifications. */
10983 if (!valid_image_p (image
))
10986 /* Display the tool-bar button pressed, or depressed. */
10987 plist
= Fcopy_sequence (XCDR (image
));
10989 /* Compute margin and relief to draw. */
10990 relief
= (tool_bar_button_relief
>= 0
10991 ? tool_bar_button_relief
10992 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
10993 hmargin
= vmargin
= relief
;
10995 if (INTEGERP (Vtool_bar_button_margin
)
10996 && XINT (Vtool_bar_button_margin
) > 0)
10998 hmargin
+= XFASTINT (Vtool_bar_button_margin
);
10999 vmargin
+= XFASTINT (Vtool_bar_button_margin
);
11001 else if (CONSP (Vtool_bar_button_margin
))
11003 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
11004 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
11005 hmargin
+= XFASTINT (XCAR (Vtool_bar_button_margin
));
11007 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
11008 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
11009 vmargin
+= XFASTINT (XCDR (Vtool_bar_button_margin
));
11012 if (auto_raise_tool_bar_buttons_p
)
11014 /* Add a `:relief' property to the image spec if the item is
11018 plist
= Fplist_put (plist
, QCrelief
, make_number (-relief
));
11025 /* If image is selected, display it pressed, i.e. with a
11026 negative relief. If it's not selected, display it with a
11028 plist
= Fplist_put (plist
, QCrelief
,
11030 ? make_number (-relief
)
11031 : make_number (relief
)));
11036 /* Put a margin around the image. */
11037 if (hmargin
|| vmargin
)
11039 if (hmargin
== vmargin
)
11040 plist
= Fplist_put (plist
, QCmargin
, make_number (hmargin
));
11042 plist
= Fplist_put (plist
, QCmargin
,
11043 Fcons (make_number (hmargin
),
11044 make_number (vmargin
)));
11047 /* If button is not enabled, and we don't have special images
11048 for the disabled state, make the image appear disabled by
11049 applying an appropriate algorithm to it. */
11050 if (!enabled_p
&& idx
< 0)
11051 plist
= Fplist_put (plist
, QCconversion
, Qdisabled
);
11053 /* Put a `display' text property on the string for the image to
11054 display. Put a `menu-item' property on the string that gives
11055 the start of this item's properties in the tool-bar items
11057 image
= Fcons (Qimage
, plist
);
11058 props
= list4 (Qdisplay
, image
,
11059 Qmenu_item
, make_number (i
* TOOL_BAR_ITEM_NSLOTS
));
11061 /* Let the last image hide all remaining spaces in the tool bar
11062 string. The string can be longer than needed when we reuse a
11063 previous string. */
11064 if (i
+ 1 == f
->n_tool_bar_items
)
11065 end
= SCHARS (f
->desired_tool_bar_string
);
11068 Fadd_text_properties (make_number (i
), make_number (end
),
11069 props
, f
->desired_tool_bar_string
);
11077 /* Display one line of the tool-bar of frame IT->f.
11079 HEIGHT specifies the desired height of the tool-bar line.
11080 If the actual height of the glyph row is less than HEIGHT, the
11081 row's height is increased to HEIGHT, and the icons are centered
11082 vertically in the new height.
11084 If HEIGHT is -1, we are counting needed tool-bar lines, so don't
11085 count a final empty row in case the tool-bar width exactly matches
11090 display_tool_bar_line (struct it
*it
, int height
)
11092 struct glyph_row
*row
= it
->glyph_row
;
11093 int max_x
= it
->last_visible_x
;
11094 struct glyph
*last
;
11096 prepare_desired_row (row
);
11097 row
->y
= it
->current_y
;
11099 /* Note that this isn't made use of if the face hasn't a box,
11100 so there's no need to check the face here. */
11101 it
->start_of_box_run_p
= 1;
11103 while (it
->current_x
< max_x
)
11105 int x
, n_glyphs_before
, i
, nglyphs
;
11106 struct it it_before
;
11108 /* Get the next display element. */
11109 if (!get_next_display_element (it
))
11111 /* Don't count empty row if we are counting needed tool-bar lines. */
11112 if (height
< 0 && !it
->hpos
)
11117 /* Produce glyphs. */
11118 n_glyphs_before
= row
->used
[TEXT_AREA
];
11121 PRODUCE_GLYPHS (it
);
11123 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
11125 x
= it_before
.current_x
;
11126 while (i
< nglyphs
)
11128 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
11130 if (x
+ glyph
->pixel_width
> max_x
)
11132 /* Glyph doesn't fit on line. Backtrack. */
11133 row
->used
[TEXT_AREA
] = n_glyphs_before
;
11135 /* If this is the only glyph on this line, it will never fit on the
11136 tool-bar, so skip it. But ensure there is at least one glyph,
11137 so we don't accidentally disable the tool-bar. */
11138 if (n_glyphs_before
== 0
11139 && (it
->vpos
> 0 || IT_STRING_CHARPOS (*it
) < it
->end_charpos
-1))
11145 x
+= glyph
->pixel_width
;
11149 /* Stop at line end. */
11150 if (ITERATOR_AT_END_OF_LINE_P (it
))
11153 set_iterator_to_next (it
, 1);
11158 row
->displays_text_p
= row
->used
[TEXT_AREA
] != 0;
11160 /* Use default face for the border below the tool bar.
11162 FIXME: When auto-resize-tool-bars is grow-only, there is
11163 no additional border below the possibly empty tool-bar lines.
11164 So to make the extra empty lines look "normal", we have to
11165 use the tool-bar face for the border too. */
11166 if (!row
->displays_text_p
&& !EQ (Vauto_resize_tool_bars
, Qgrow_only
))
11167 it
->face_id
= DEFAULT_FACE_ID
;
11169 extend_face_to_end_of_line (it
);
11170 last
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
11171 last
->right_box_line_p
= 1;
11172 if (last
== row
->glyphs
[TEXT_AREA
])
11173 last
->left_box_line_p
= 1;
11175 /* Make line the desired height and center it vertically. */
11176 if ((height
-= it
->max_ascent
+ it
->max_descent
) > 0)
11178 /* Don't add more than one line height. */
11179 height
%= FRAME_LINE_HEIGHT (it
->f
);
11180 it
->max_ascent
+= height
/ 2;
11181 it
->max_descent
+= (height
+ 1) / 2;
11184 compute_line_metrics (it
);
11186 /* If line is empty, make it occupy the rest of the tool-bar. */
11187 if (!row
->displays_text_p
)
11189 row
->height
= row
->phys_height
= it
->last_visible_y
- row
->y
;
11190 row
->visible_height
= row
->height
;
11191 row
->ascent
= row
->phys_ascent
= 0;
11192 row
->extra_line_spacing
= 0;
11195 row
->full_width_p
= 1;
11196 row
->continued_p
= 0;
11197 row
->truncated_on_left_p
= 0;
11198 row
->truncated_on_right_p
= 0;
11200 it
->current_x
= it
->hpos
= 0;
11201 it
->current_y
+= row
->height
;
11207 /* Max tool-bar height. */
11209 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
11210 ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
11212 /* Value is the number of screen lines needed to make all tool-bar
11213 items of frame F visible. The number of actual rows needed is
11214 returned in *N_ROWS if non-NULL. */
11217 tool_bar_lines_needed (struct frame
*f
, int *n_rows
)
11219 struct window
*w
= XWINDOW (f
->tool_bar_window
);
11221 /* tool_bar_lines_needed is called from redisplay_tool_bar after building
11222 the desired matrix, so use (unused) mode-line row as temporary row to
11223 avoid destroying the first tool-bar row. */
11224 struct glyph_row
*temp_row
= MATRIX_MODE_LINE_ROW (w
->desired_matrix
);
11226 /* Initialize an iterator for iteration over
11227 F->desired_tool_bar_string in the tool-bar window of frame F. */
11228 init_iterator (&it
, w
, -1, -1, temp_row
, TOOL_BAR_FACE_ID
);
11229 it
.first_visible_x
= 0;
11230 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
11231 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
11232 it
.paragraph_embedding
= L2R
;
11234 while (!ITERATOR_AT_END_P (&it
))
11236 clear_glyph_row (temp_row
);
11237 it
.glyph_row
= temp_row
;
11238 display_tool_bar_line (&it
, -1);
11240 clear_glyph_row (temp_row
);
11242 /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar. */
11244 *n_rows
= it
.vpos
> 0 ? it
.vpos
: -1;
11246 return (it
.current_y
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
11250 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed
, Stool_bar_lines_needed
,
11252 doc
: /* Return the number of lines occupied by the tool bar of FRAME. */)
11253 (Lisp_Object frame
)
11260 frame
= selected_frame
;
11262 CHECK_FRAME (frame
);
11263 f
= XFRAME (frame
);
11265 if (WINDOWP (f
->tool_bar_window
)
11266 || (w
= XWINDOW (f
->tool_bar_window
),
11267 WINDOW_TOTAL_LINES (w
) > 0))
11269 update_tool_bar (f
, 1);
11270 if (f
->n_tool_bar_items
)
11272 build_desired_tool_bar_string (f
);
11273 nlines
= tool_bar_lines_needed (f
, NULL
);
11277 return make_number (nlines
);
11281 /* Display the tool-bar of frame F. Value is non-zero if tool-bar's
11282 height should be changed. */
11285 redisplay_tool_bar (struct frame
*f
)
11289 struct glyph_row
*row
;
11291 #if defined (USE_GTK) || defined (HAVE_NS)
11292 if (FRAME_EXTERNAL_TOOL_BAR (f
))
11293 update_frame_tool_bar (f
);
11297 /* If frame hasn't a tool-bar window or if it is zero-height, don't
11298 do anything. This means you must start with tool-bar-lines
11299 non-zero to get the auto-sizing effect. Or in other words, you
11300 can turn off tool-bars by specifying tool-bar-lines zero. */
11301 if (!WINDOWP (f
->tool_bar_window
)
11302 || (w
= XWINDOW (f
->tool_bar_window
),
11303 WINDOW_TOTAL_LINES (w
) == 0))
11306 /* Set up an iterator for the tool-bar window. */
11307 init_iterator (&it
, w
, -1, -1, w
->desired_matrix
->rows
, TOOL_BAR_FACE_ID
);
11308 it
.first_visible_x
= 0;
11309 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
11310 row
= it
.glyph_row
;
11312 /* Build a string that represents the contents of the tool-bar. */
11313 build_desired_tool_bar_string (f
);
11314 reseat_to_string (&it
, NULL
, f
->desired_tool_bar_string
, 0, 0, 0, -1);
11315 /* FIXME: This should be controlled by a user option. But it
11316 doesn't make sense to have an R2L tool bar if the menu bar cannot
11317 be drawn also R2L, and making the menu bar R2L is tricky due
11318 toolkit-specific code that implements it. If an R2L tool bar is
11319 ever supported, display_tool_bar_line should also be augmented to
11320 call unproduce_glyphs like display_line and display_string
11322 it
.paragraph_embedding
= L2R
;
11324 if (f
->n_tool_bar_rows
== 0)
11328 if ((nlines
= tool_bar_lines_needed (f
, &f
->n_tool_bar_rows
),
11329 nlines
!= WINDOW_TOTAL_LINES (w
)))
11332 int old_height
= WINDOW_TOTAL_LINES (w
);
11334 XSETFRAME (frame
, f
);
11335 Fmodify_frame_parameters (frame
,
11336 Fcons (Fcons (Qtool_bar_lines
,
11337 make_number (nlines
)),
11339 if (WINDOW_TOTAL_LINES (w
) != old_height
)
11341 clear_glyph_matrix (w
->desired_matrix
);
11342 fonts_changed_p
= 1;
11348 /* Display as many lines as needed to display all tool-bar items. */
11350 if (f
->n_tool_bar_rows
> 0)
11352 int border
, rows
, height
, extra
;
11354 if (INTEGERP (Vtool_bar_border
))
11355 border
= XINT (Vtool_bar_border
);
11356 else if (EQ (Vtool_bar_border
, Qinternal_border_width
))
11357 border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
11358 else if (EQ (Vtool_bar_border
, Qborder_width
))
11359 border
= f
->border_width
;
11365 rows
= f
->n_tool_bar_rows
;
11366 height
= max (1, (it
.last_visible_y
- border
) / rows
);
11367 extra
= it
.last_visible_y
- border
- height
* rows
;
11369 while (it
.current_y
< it
.last_visible_y
)
11372 if (extra
> 0 && rows
-- > 0)
11374 h
= (extra
+ rows
- 1) / rows
;
11377 display_tool_bar_line (&it
, height
+ h
);
11382 while (it
.current_y
< it
.last_visible_y
)
11383 display_tool_bar_line (&it
, 0);
11386 /* It doesn't make much sense to try scrolling in the tool-bar
11387 window, so don't do it. */
11388 w
->desired_matrix
->no_scrolling_p
= 1;
11389 w
->must_be_updated_p
= 1;
11391 if (!NILP (Vauto_resize_tool_bars
))
11393 int max_tool_bar_height
= MAX_FRAME_TOOL_BAR_HEIGHT (f
);
11394 int change_height_p
= 0;
11396 /* If we couldn't display everything, change the tool-bar's
11397 height if there is room for more. */
11398 if (IT_STRING_CHARPOS (it
) < it
.end_charpos
11399 && it
.current_y
< max_tool_bar_height
)
11400 change_height_p
= 1;
11402 row
= it
.glyph_row
- 1;
11404 /* If there are blank lines at the end, except for a partially
11405 visible blank line at the end that is smaller than
11406 FRAME_LINE_HEIGHT, change the tool-bar's height. */
11407 if (!row
->displays_text_p
11408 && row
->height
>= FRAME_LINE_HEIGHT (f
))
11409 change_height_p
= 1;
11411 /* If row displays tool-bar items, but is partially visible,
11412 change the tool-bar's height. */
11413 if (row
->displays_text_p
11414 && MATRIX_ROW_BOTTOM_Y (row
) > it
.last_visible_y
11415 && MATRIX_ROW_BOTTOM_Y (row
) < max_tool_bar_height
)
11416 change_height_p
= 1;
11418 /* Resize windows as needed by changing the `tool-bar-lines'
11419 frame parameter. */
11420 if (change_height_p
)
11423 int old_height
= WINDOW_TOTAL_LINES (w
);
11425 int nlines
= tool_bar_lines_needed (f
, &nrows
);
11427 change_height_p
= ((EQ (Vauto_resize_tool_bars
, Qgrow_only
)
11428 && !f
->minimize_tool_bar_window_p
)
11429 ? (nlines
> old_height
)
11430 : (nlines
!= old_height
));
11431 f
->minimize_tool_bar_window_p
= 0;
11433 if (change_height_p
)
11435 XSETFRAME (frame
, f
);
11436 Fmodify_frame_parameters (frame
,
11437 Fcons (Fcons (Qtool_bar_lines
,
11438 make_number (nlines
)),
11440 if (WINDOW_TOTAL_LINES (w
) != old_height
)
11442 clear_glyph_matrix (w
->desired_matrix
);
11443 f
->n_tool_bar_rows
= nrows
;
11444 fonts_changed_p
= 1;
11451 f
->minimize_tool_bar_window_p
= 0;
11456 /* Get information about the tool-bar item which is displayed in GLYPH
11457 on frame F. Return in *PROP_IDX the index where tool-bar item
11458 properties start in F->tool_bar_items. Value is zero if
11459 GLYPH doesn't display a tool-bar item. */
11462 tool_bar_item_info (struct frame
*f
, struct glyph
*glyph
, int *prop_idx
)
11468 /* This function can be called asynchronously, which means we must
11469 exclude any possibility that Fget_text_property signals an
11471 charpos
= min (SCHARS (f
->current_tool_bar_string
), glyph
->charpos
);
11472 charpos
= max (0, charpos
);
11474 /* Get the text property `menu-item' at pos. The value of that
11475 property is the start index of this item's properties in
11476 F->tool_bar_items. */
11477 prop
= Fget_text_property (make_number (charpos
),
11478 Qmenu_item
, f
->current_tool_bar_string
);
11479 if (INTEGERP (prop
))
11481 *prop_idx
= XINT (prop
);
11491 /* Get information about the tool-bar item at position X/Y on frame F.
11492 Return in *GLYPH a pointer to the glyph of the tool-bar item in
11493 the current matrix of the tool-bar window of F, or NULL if not
11494 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
11495 item in F->tool_bar_items. Value is
11497 -1 if X/Y is not on a tool-bar item
11498 0 if X/Y is on the same item that was highlighted before.
11502 get_tool_bar_item (struct frame
*f
, int x
, int y
, struct glyph
**glyph
,
11503 int *hpos
, int *vpos
, int *prop_idx
)
11505 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
11506 struct window
*w
= XWINDOW (f
->tool_bar_window
);
11509 /* Find the glyph under X/Y. */
11510 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, 0, 0, &area
);
11511 if (*glyph
== NULL
)
11514 /* Get the start of this tool-bar item's properties in
11515 f->tool_bar_items. */
11516 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
11519 /* Is mouse on the highlighted item? */
11520 if (EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)
11521 && *vpos
>= hlinfo
->mouse_face_beg_row
11522 && *vpos
<= hlinfo
->mouse_face_end_row
11523 && (*vpos
> hlinfo
->mouse_face_beg_row
11524 || *hpos
>= hlinfo
->mouse_face_beg_col
)
11525 && (*vpos
< hlinfo
->mouse_face_end_row
11526 || *hpos
< hlinfo
->mouse_face_end_col
11527 || hlinfo
->mouse_face_past_end
))
11535 Handle mouse button event on the tool-bar of frame F, at
11536 frame-relative coordinates X/Y. DOWN_P is 1 for a button press,
11537 0 for button release. MODIFIERS is event modifiers for button
11541 handle_tool_bar_click (struct frame
*f
, int x
, int y
, int down_p
,
11542 unsigned int modifiers
)
11544 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
11545 struct window
*w
= XWINDOW (f
->tool_bar_window
);
11546 int hpos
, vpos
, prop_idx
;
11547 struct glyph
*glyph
;
11548 Lisp_Object enabled_p
;
11550 /* If not on the highlighted tool-bar item, return. */
11551 frame_to_window_pixel_xy (w
, &x
, &y
);
11552 if (get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
11555 /* If item is disabled, do nothing. */
11556 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
11557 if (NILP (enabled_p
))
11562 /* Show item in pressed state. */
11563 show_mouse_face (hlinfo
, DRAW_IMAGE_SUNKEN
);
11564 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
11565 last_tool_bar_item
= prop_idx
;
11569 Lisp_Object key
, frame
;
11570 struct input_event event
;
11571 EVENT_INIT (event
);
11573 /* Show item in released state. */
11574 show_mouse_face (hlinfo
, DRAW_IMAGE_RAISED
);
11575 hlinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
11577 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
11579 XSETFRAME (frame
, f
);
11580 event
.kind
= TOOL_BAR_EVENT
;
11581 event
.frame_or_window
= frame
;
11583 kbd_buffer_store_event (&event
);
11585 event
.kind
= TOOL_BAR_EVENT
;
11586 event
.frame_or_window
= frame
;
11588 event
.modifiers
= modifiers
;
11589 kbd_buffer_store_event (&event
);
11590 last_tool_bar_item
= -1;
11595 /* Possibly highlight a tool-bar item on frame F when mouse moves to
11596 tool-bar window-relative coordinates X/Y. Called from
11597 note_mouse_highlight. */
11600 note_tool_bar_highlight (struct frame
*f
, int x
, int y
)
11602 Lisp_Object window
= f
->tool_bar_window
;
11603 struct window
*w
= XWINDOW (window
);
11604 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
11605 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
11607 struct glyph
*glyph
;
11608 struct glyph_row
*row
;
11610 Lisp_Object enabled_p
;
11612 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
11613 int mouse_down_p
, rc
;
11615 /* Function note_mouse_highlight is called with negative X/Y
11616 values when mouse moves outside of the frame. */
11617 if (x
<= 0 || y
<= 0)
11619 clear_mouse_face (hlinfo
);
11623 rc
= get_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
11626 /* Not on tool-bar item. */
11627 clear_mouse_face (hlinfo
);
11631 /* On same tool-bar item as before. */
11632 goto set_help_echo
;
11634 clear_mouse_face (hlinfo
);
11636 /* Mouse is down, but on different tool-bar item? */
11637 mouse_down_p
= (dpyinfo
->grabbed
11638 && f
== last_mouse_frame
11639 && FRAME_LIVE_P (f
));
11641 && last_tool_bar_item
!= prop_idx
)
11644 hlinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
11645 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
11647 /* If tool-bar item is not enabled, don't highlight it. */
11648 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
11649 if (!NILP (enabled_p
))
11651 /* Compute the x-position of the glyph. In front and past the
11652 image is a space. We include this in the highlighted area. */
11653 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
11654 for (i
= x
= 0; i
< hpos
; ++i
)
11655 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
11657 /* Record this as the current active region. */
11658 hlinfo
->mouse_face_beg_col
= hpos
;
11659 hlinfo
->mouse_face_beg_row
= vpos
;
11660 hlinfo
->mouse_face_beg_x
= x
;
11661 hlinfo
->mouse_face_beg_y
= row
->y
;
11662 hlinfo
->mouse_face_past_end
= 0;
11664 hlinfo
->mouse_face_end_col
= hpos
+ 1;
11665 hlinfo
->mouse_face_end_row
= vpos
;
11666 hlinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
11667 hlinfo
->mouse_face_end_y
= row
->y
;
11668 hlinfo
->mouse_face_window
= window
;
11669 hlinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
11671 /* Display it as active. */
11672 show_mouse_face (hlinfo
, draw
);
11673 hlinfo
->mouse_face_image_state
= draw
;
11678 /* Set help_echo_string to a help string to display for this tool-bar item.
11679 XTread_socket does the rest. */
11680 help_echo_object
= help_echo_window
= Qnil
;
11681 help_echo_pos
= -1;
11682 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
11683 if (NILP (help_echo_string
))
11684 help_echo_string
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
11687 #endif /* HAVE_WINDOW_SYSTEM */
11691 /************************************************************************
11692 Horizontal scrolling
11693 ************************************************************************/
11695 static int hscroll_window_tree (Lisp_Object
);
11696 static int hscroll_windows (Lisp_Object
);
11698 /* For all leaf windows in the window tree rooted at WINDOW, set their
11699 hscroll value so that PT is (i) visible in the window, and (ii) so
11700 that it is not within a certain margin at the window's left and
11701 right border. Value is non-zero if any window's hscroll has been
11705 hscroll_window_tree (Lisp_Object window
)
11707 int hscrolled_p
= 0;
11708 int hscroll_relative_p
= FLOATP (Vhscroll_step
);
11709 int hscroll_step_abs
= 0;
11710 double hscroll_step_rel
= 0;
11712 if (hscroll_relative_p
)
11714 hscroll_step_rel
= XFLOAT_DATA (Vhscroll_step
);
11715 if (hscroll_step_rel
< 0)
11717 hscroll_relative_p
= 0;
11718 hscroll_step_abs
= 0;
11721 else if (INTEGERP (Vhscroll_step
))
11723 hscroll_step_abs
= XINT (Vhscroll_step
);
11724 if (hscroll_step_abs
< 0)
11725 hscroll_step_abs
= 0;
11728 hscroll_step_abs
= 0;
11730 while (WINDOWP (window
))
11732 struct window
*w
= XWINDOW (window
);
11734 if (WINDOWP (w
->hchild
))
11735 hscrolled_p
|= hscroll_window_tree (w
->hchild
);
11736 else if (WINDOWP (w
->vchild
))
11737 hscrolled_p
|= hscroll_window_tree (w
->vchild
);
11738 else if (w
->cursor
.vpos
>= 0)
11741 int text_area_width
;
11742 struct glyph_row
*current_cursor_row
11743 = MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
11744 struct glyph_row
*desired_cursor_row
11745 = MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
);
11746 struct glyph_row
*cursor_row
11747 = (desired_cursor_row
->enabled_p
11748 ? desired_cursor_row
11749 : current_cursor_row
);
11751 text_area_width
= window_box_width (w
, TEXT_AREA
);
11753 /* Scroll when cursor is inside this scroll margin. */
11754 h_margin
= hscroll_margin
* WINDOW_FRAME_COLUMN_WIDTH (w
);
11756 if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode
, w
->buffer
))
11757 && ((XFASTINT (w
->hscroll
)
11758 && w
->cursor
.x
<= h_margin
)
11759 || (cursor_row
->enabled_p
11760 && cursor_row
->truncated_on_right_p
11761 && (w
->cursor
.x
>= text_area_width
- h_margin
))))
11765 struct buffer
*saved_current_buffer
;
11769 /* Find point in a display of infinite width. */
11770 saved_current_buffer
= current_buffer
;
11771 current_buffer
= XBUFFER (w
->buffer
);
11773 if (w
== XWINDOW (selected_window
))
11777 pt
= marker_position (w
->pointm
);
11778 pt
= max (BEGV
, pt
);
11782 /* Move iterator to pt starting at cursor_row->start in
11783 a line with infinite width. */
11784 init_to_row_start (&it
, w
, cursor_row
);
11785 it
.last_visible_x
= INFINITY
;
11786 move_it_in_display_line_to (&it
, pt
, -1, MOVE_TO_POS
);
11787 current_buffer
= saved_current_buffer
;
11789 /* Position cursor in window. */
11790 if (!hscroll_relative_p
&& hscroll_step_abs
== 0)
11791 hscroll
= max (0, (it
.current_x
11792 - (ITERATOR_AT_END_OF_LINE_P (&it
)
11793 ? (text_area_width
- 4 * FRAME_COLUMN_WIDTH (it
.f
))
11794 : (text_area_width
/ 2))))
11795 / FRAME_COLUMN_WIDTH (it
.f
);
11796 else if (w
->cursor
.x
>= text_area_width
- h_margin
)
11798 if (hscroll_relative_p
)
11799 wanted_x
= text_area_width
* (1 - hscroll_step_rel
)
11802 wanted_x
= text_area_width
11803 - hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
11806 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
11810 if (hscroll_relative_p
)
11811 wanted_x
= text_area_width
* hscroll_step_rel
11814 wanted_x
= hscroll_step_abs
* FRAME_COLUMN_WIDTH (it
.f
)
11817 = max (0, it
.current_x
- wanted_x
) / FRAME_COLUMN_WIDTH (it
.f
);
11819 hscroll
= max (hscroll
, XFASTINT (w
->min_hscroll
));
11821 /* Don't call Fset_window_hscroll if value hasn't
11822 changed because it will prevent redisplay
11824 if (XFASTINT (w
->hscroll
) != hscroll
)
11826 XBUFFER (w
->buffer
)->prevent_redisplay_optimizations_p
= 1;
11827 w
->hscroll
= make_number (hscroll
);
11836 /* Value is non-zero if hscroll of any leaf window has been changed. */
11837 return hscrolled_p
;
11841 /* Set hscroll so that cursor is visible and not inside horizontal
11842 scroll margins for all windows in the tree rooted at WINDOW. See
11843 also hscroll_window_tree above. Value is non-zero if any window's
11844 hscroll has been changed. If it has, desired matrices on the frame
11845 of WINDOW are cleared. */
11848 hscroll_windows (Lisp_Object window
)
11850 int hscrolled_p
= hscroll_window_tree (window
);
11852 clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window
))));
11853 return hscrolled_p
;
11858 /************************************************************************
11860 ************************************************************************/
11862 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
11863 to a non-zero value. This is sometimes handy to have in a debugger
11868 /* First and last unchanged row for try_window_id. */
11870 int debug_first_unchanged_at_end_vpos
;
11871 int debug_last_unchanged_at_beg_vpos
;
11873 /* Delta vpos and y. */
11875 int debug_dvpos
, debug_dy
;
11877 /* Delta in characters and bytes for try_window_id. */
11879 EMACS_INT debug_delta
, debug_delta_bytes
;
11881 /* Values of window_end_pos and window_end_vpos at the end of
11884 EMACS_INT debug_end_vpos
;
11886 /* Append a string to W->desired_matrix->method. FMT is a printf
11887 format string. A1...A9 are a supplement for a variable-length
11888 argument list. If trace_redisplay_p is non-zero also printf the
11889 resulting string to stderr. */
11892 debug_method_add (w
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
)
11895 int a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
;
11898 char *method
= w
->desired_matrix
->method
;
11899 int len
= strlen (method
);
11900 int size
= sizeof w
->desired_matrix
->method
;
11901 int remaining
= size
- len
- 1;
11903 sprintf (buffer
, fmt
, a1
, a2
, a3
, a4
, a5
, a6
, a7
, a8
, a9
);
11904 if (len
&& remaining
)
11907 --remaining
, ++len
;
11910 strncpy (method
+ len
, buffer
, remaining
);
11912 if (trace_redisplay_p
)
11913 fprintf (stderr
, "%p (%s): %s\n",
11915 ((BUFFERP (w
->buffer
)
11916 && STRINGP (XBUFFER (w
->buffer
)->name
))
11917 ? SSDATA (XBUFFER (w
->buffer
)->name
)
11922 #endif /* GLYPH_DEBUG */
11925 /* Value is non-zero if all changes in window W, which displays
11926 current_buffer, are in the text between START and END. START is a
11927 buffer position, END is given as a distance from Z. Used in
11928 redisplay_internal for display optimization. */
11931 text_outside_line_unchanged_p (struct window
*w
,
11932 EMACS_INT start
, EMACS_INT end
)
11934 int unchanged_p
= 1;
11936 /* If text or overlays have changed, see where. */
11937 if (XFASTINT (w
->last_modified
) < MODIFF
11938 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
11940 /* Gap in the line? */
11941 if (GPT
< start
|| Z
- GPT
< end
)
11944 /* Changes start in front of the line, or end after it? */
11946 && (BEG_UNCHANGED
< start
- 1
11947 || END_UNCHANGED
< end
))
11950 /* If selective display, can't optimize if changes start at the
11951 beginning of the line. */
11953 && INTEGERP (BVAR (current_buffer
, selective_display
))
11954 && XINT (BVAR (current_buffer
, selective_display
)) > 0
11955 && (BEG_UNCHANGED
< start
|| GPT
<= start
))
11958 /* If there are overlays at the start or end of the line, these
11959 may have overlay strings with newlines in them. A change at
11960 START, for instance, may actually concern the display of such
11961 overlay strings as well, and they are displayed on different
11962 lines. So, quickly rule out this case. (For the future, it
11963 might be desirable to implement something more telling than
11964 just BEG/END_UNCHANGED.) */
11967 if (BEG
+ BEG_UNCHANGED
== start
11968 && overlay_touches_p (start
))
11970 if (END_UNCHANGED
== end
11971 && overlay_touches_p (Z
- end
))
11975 /* Under bidi reordering, adding or deleting a character in the
11976 beginning of a paragraph, before the first strong directional
11977 character, can change the base direction of the paragraph (unless
11978 the buffer specifies a fixed paragraph direction), which will
11979 require to redisplay the whole paragraph. It might be worthwhile
11980 to find the paragraph limits and widen the range of redisplayed
11981 lines to that, but for now just give up this optimization. */
11982 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
11983 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
11987 return unchanged_p
;
11991 /* Do a frame update, taking possible shortcuts into account. This is
11992 the main external entry point for redisplay.
11994 If the last redisplay displayed an echo area message and that message
11995 is no longer requested, we clear the echo area or bring back the
11996 mini-buffer if that is in use. */
12001 redisplay_internal ();
12006 overlay_arrow_string_or_property (Lisp_Object var
)
12010 if (val
= Fget (var
, Qoverlay_arrow_string
), STRINGP (val
))
12013 return Voverlay_arrow_string
;
12016 /* Return 1 if there are any overlay-arrows in current_buffer. */
12018 overlay_arrow_in_current_buffer_p (void)
12022 for (vlist
= Voverlay_arrow_variable_list
;
12024 vlist
= XCDR (vlist
))
12026 Lisp_Object var
= XCAR (vlist
);
12029 if (!SYMBOLP (var
))
12031 val
= find_symbol_value (var
);
12033 && current_buffer
== XMARKER (val
)->buffer
)
12040 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
12044 overlay_arrows_changed_p (void)
12048 for (vlist
= Voverlay_arrow_variable_list
;
12050 vlist
= XCDR (vlist
))
12052 Lisp_Object var
= XCAR (vlist
);
12053 Lisp_Object val
, pstr
;
12055 if (!SYMBOLP (var
))
12057 val
= find_symbol_value (var
);
12058 if (!MARKERP (val
))
12060 if (! EQ (COERCE_MARKER (val
),
12061 Fget (var
, Qlast_arrow_position
))
12062 || ! (pstr
= overlay_arrow_string_or_property (var
),
12063 EQ (pstr
, Fget (var
, Qlast_arrow_string
))))
12069 /* Mark overlay arrows to be updated on next redisplay. */
12072 update_overlay_arrows (int up_to_date
)
12076 for (vlist
= Voverlay_arrow_variable_list
;
12078 vlist
= XCDR (vlist
))
12080 Lisp_Object var
= XCAR (vlist
);
12082 if (!SYMBOLP (var
))
12085 if (up_to_date
> 0)
12087 Lisp_Object val
= find_symbol_value (var
);
12088 Fput (var
, Qlast_arrow_position
,
12089 COERCE_MARKER (val
));
12090 Fput (var
, Qlast_arrow_string
,
12091 overlay_arrow_string_or_property (var
));
12093 else if (up_to_date
< 0
12094 || !NILP (Fget (var
, Qlast_arrow_position
)))
12096 Fput (var
, Qlast_arrow_position
, Qt
);
12097 Fput (var
, Qlast_arrow_string
, Qt
);
12103 /* Return overlay arrow string to display at row.
12104 Return integer (bitmap number) for arrow bitmap in left fringe.
12105 Return nil if no overlay arrow. */
12108 overlay_arrow_at_row (struct it
*it
, struct glyph_row
*row
)
12112 for (vlist
= Voverlay_arrow_variable_list
;
12114 vlist
= XCDR (vlist
))
12116 Lisp_Object var
= XCAR (vlist
);
12119 if (!SYMBOLP (var
))
12122 val
= find_symbol_value (var
);
12125 && current_buffer
== XMARKER (val
)->buffer
12126 && (MATRIX_ROW_START_CHARPOS (row
) == marker_position (val
)))
12128 if (FRAME_WINDOW_P (it
->f
)
12129 /* FIXME: if ROW->reversed_p is set, this should test
12130 the right fringe, not the left one. */
12131 && WINDOW_LEFT_FRINGE_WIDTH (it
->w
) > 0)
12133 #ifdef HAVE_WINDOW_SYSTEM
12134 if (val
= Fget (var
, Qoverlay_arrow_bitmap
), SYMBOLP (val
))
12137 if ((fringe_bitmap
= lookup_fringe_bitmap (val
)) != 0)
12138 return make_number (fringe_bitmap
);
12141 return make_number (-1); /* Use default arrow bitmap */
12143 return overlay_arrow_string_or_property (var
);
12150 /* Return 1 if point moved out of or into a composition. Otherwise
12151 return 0. PREV_BUF and PREV_PT are the last point buffer and
12152 position. BUF and PT are the current point buffer and position. */
12155 check_point_in_composition (struct buffer
*prev_buf
, EMACS_INT prev_pt
,
12156 struct buffer
*buf
, EMACS_INT pt
)
12158 EMACS_INT start
, end
;
12160 Lisp_Object buffer
;
12162 XSETBUFFER (buffer
, buf
);
12163 /* Check a composition at the last point if point moved within the
12165 if (prev_buf
== buf
)
12168 /* Point didn't move. */
12171 if (prev_pt
> BUF_BEGV (buf
) && prev_pt
< BUF_ZV (buf
)
12172 && find_composition (prev_pt
, -1, &start
, &end
, &prop
, buffer
)
12173 && COMPOSITION_VALID_P (start
, end
, prop
)
12174 && start
< prev_pt
&& end
> prev_pt
)
12175 /* The last point was within the composition. Return 1 iff
12176 point moved out of the composition. */
12177 return (pt
<= start
|| pt
>= end
);
12180 /* Check a composition at the current point. */
12181 return (pt
> BUF_BEGV (buf
) && pt
< BUF_ZV (buf
)
12182 && find_composition (pt
, -1, &start
, &end
, &prop
, buffer
)
12183 && COMPOSITION_VALID_P (start
, end
, prop
)
12184 && start
< pt
&& end
> pt
);
12188 /* Reconsider the setting of B->clip_changed which is displayed
12192 reconsider_clip_changes (struct window
*w
, struct buffer
*b
)
12194 if (b
->clip_changed
12195 && !NILP (w
->window_end_valid
)
12196 && w
->current_matrix
->buffer
== b
12197 && w
->current_matrix
->zv
== BUF_ZV (b
)
12198 && w
->current_matrix
->begv
== BUF_BEGV (b
))
12199 b
->clip_changed
= 0;
12201 /* If display wasn't paused, and W is not a tool bar window, see if
12202 point has been moved into or out of a composition. In that case,
12203 we set b->clip_changed to 1 to force updating the screen. If
12204 b->clip_changed has already been set to 1, we can skip this
12206 if (!b
->clip_changed
12207 && BUFFERP (w
->buffer
) && !NILP (w
->window_end_valid
))
12211 if (w
== XWINDOW (selected_window
))
12214 pt
= marker_position (w
->pointm
);
12216 if ((w
->current_matrix
->buffer
!= XBUFFER (w
->buffer
)
12217 || pt
!= XINT (w
->last_point
))
12218 && check_point_in_composition (w
->current_matrix
->buffer
,
12219 XINT (w
->last_point
),
12220 XBUFFER (w
->buffer
), pt
))
12221 b
->clip_changed
= 1;
12226 /* Select FRAME to forward the values of frame-local variables into C
12227 variables so that the redisplay routines can access those values
12231 select_frame_for_redisplay (Lisp_Object frame
)
12233 Lisp_Object tail
, tem
;
12234 Lisp_Object old
= selected_frame
;
12235 struct Lisp_Symbol
*sym
;
12237 xassert (FRAMEP (frame
) && FRAME_LIVE_P (XFRAME (frame
)));
12239 selected_frame
= frame
;
12242 for (tail
= XFRAME (frame
)->param_alist
; CONSP (tail
); tail
= XCDR (tail
))
12243 if (CONSP (XCAR (tail
))
12244 && (tem
= XCAR (XCAR (tail
)),
12246 && (sym
= indirect_variable (XSYMBOL (tem
)),
12247 sym
->redirect
== SYMBOL_LOCALIZED
)
12248 && sym
->val
.blv
->frame_local
)
12249 /* Use find_symbol_value rather than Fsymbol_value
12250 to avoid an error if it is void. */
12251 find_symbol_value (tem
);
12252 } while (!EQ (frame
, old
) && (frame
= old
, 1));
12256 #define STOP_POLLING \
12257 do { if (! polling_stopped_here) stop_polling (); \
12258 polling_stopped_here = 1; } while (0)
12260 #define RESUME_POLLING \
12261 do { if (polling_stopped_here) start_polling (); \
12262 polling_stopped_here = 0; } while (0)
12265 /* Perhaps in the future avoid recentering windows if it
12266 is not necessary; currently that causes some problems. */
12269 redisplay_internal (void)
12271 struct window
*w
= XWINDOW (selected_window
);
12275 int must_finish
= 0;
12276 struct text_pos tlbufpos
, tlendpos
;
12277 int number_of_visible_frames
;
12280 int polling_stopped_here
= 0;
12281 Lisp_Object old_frame
= selected_frame
;
12283 /* Non-zero means redisplay has to consider all windows on all
12284 frames. Zero means, only selected_window is considered. */
12285 int consider_all_windows_p
;
12287 TRACE ((stderr
, "redisplay_internal %d\n", redisplaying_p
));
12289 /* No redisplay if running in batch mode or frame is not yet fully
12290 initialized, or redisplay is explicitly turned off by setting
12291 Vinhibit_redisplay. */
12292 if (FRAME_INITIAL_P (SELECTED_FRAME ())
12293 || !NILP (Vinhibit_redisplay
))
12296 /* Don't examine these until after testing Vinhibit_redisplay.
12297 When Emacs is shutting down, perhaps because its connection to
12298 X has dropped, we should not look at them at all. */
12299 fr
= XFRAME (w
->frame
);
12300 sf
= SELECTED_FRAME ();
12302 if (!fr
->glyphs_initialized_p
)
12305 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
12306 if (popup_activated ())
12310 /* I don't think this happens but let's be paranoid. */
12311 if (redisplaying_p
)
12314 /* Record a function that resets redisplaying_p to its old value
12315 when we leave this function. */
12316 count
= SPECPDL_INDEX ();
12317 record_unwind_protect (unwind_redisplay
,
12318 Fcons (make_number (redisplaying_p
), selected_frame
));
12320 specbind (Qinhibit_free_realized_faces
, Qnil
);
12323 Lisp_Object tail
, frame
;
12325 FOR_EACH_FRAME (tail
, frame
)
12327 struct frame
*f
= XFRAME (frame
);
12328 f
->already_hscrolled_p
= 0;
12333 /* Remember the currently selected window. */
12336 if (!EQ (old_frame
, selected_frame
)
12337 && FRAME_LIVE_P (XFRAME (old_frame
)))
12338 /* When running redisplay, we play a bit fast-and-loose and allow e.g.
12339 selected_frame and selected_window to be temporarily out-of-sync so
12340 when we come back here via `goto retry', we need to resync because we
12341 may need to run Elisp code (via prepare_menu_bars). */
12342 select_frame_for_redisplay (old_frame
);
12345 reconsider_clip_changes (w
, current_buffer
);
12346 last_escape_glyph_frame
= NULL
;
12347 last_escape_glyph_face_id
= (1 << FACE_ID_BITS
);
12348 last_glyphless_glyph_frame
= NULL
;
12349 last_glyphless_glyph_face_id
= (1 << FACE_ID_BITS
);
12351 /* If new fonts have been loaded that make a glyph matrix adjustment
12352 necessary, do it. */
12353 if (fonts_changed_p
)
12355 adjust_glyphs (NULL
);
12356 ++windows_or_buffers_changed
;
12357 fonts_changed_p
= 0;
12360 /* If face_change_count is non-zero, init_iterator will free all
12361 realized faces, which includes the faces referenced from current
12362 matrices. So, we can't reuse current matrices in this case. */
12363 if (face_change_count
)
12364 ++windows_or_buffers_changed
;
12366 if ((FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
12367 && FRAME_TTY (sf
)->previous_frame
!= sf
)
12369 /* Since frames on a single ASCII terminal share the same
12370 display area, displaying a different frame means redisplay
12371 the whole thing. */
12372 windows_or_buffers_changed
++;
12373 SET_FRAME_GARBAGED (sf
);
12375 set_tty_color_mode (FRAME_TTY (sf
), sf
);
12377 FRAME_TTY (sf
)->previous_frame
= sf
;
12380 /* Set the visible flags for all frames. Do this before checking
12381 for resized or garbaged frames; they want to know if their frames
12382 are visible. See the comment in frame.h for
12383 FRAME_SAMPLE_VISIBILITY. */
12385 Lisp_Object tail
, frame
;
12387 number_of_visible_frames
= 0;
12389 FOR_EACH_FRAME (tail
, frame
)
12391 struct frame
*f
= XFRAME (frame
);
12393 FRAME_SAMPLE_VISIBILITY (f
);
12394 if (FRAME_VISIBLE_P (f
))
12395 ++number_of_visible_frames
;
12396 clear_desired_matrices (f
);
12400 /* Notice any pending interrupt request to change frame size. */
12401 do_pending_window_change (1);
12403 /* do_pending_window_change could change the selected_window due to
12404 frame resizing which makes the selected window too small. */
12405 if (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
)
12408 reconsider_clip_changes (w
, current_buffer
);
12411 /* Clear frames marked as garbaged. */
12412 if (frame_garbaged
)
12413 clear_garbaged_frames ();
12415 /* Build menubar and tool-bar items. */
12416 if (NILP (Vmemory_full
))
12417 prepare_menu_bars ();
12419 if (windows_or_buffers_changed
)
12420 update_mode_lines
++;
12422 /* Detect case that we need to write or remove a star in the mode line. */
12423 if ((SAVE_MODIFF
< MODIFF
) != !NILP (w
->last_had_star
))
12425 w
->update_mode_line
= Qt
;
12426 if (buffer_shared
> 1)
12427 update_mode_lines
++;
12430 /* Avoid invocation of point motion hooks by `current_column' below. */
12431 count1
= SPECPDL_INDEX ();
12432 specbind (Qinhibit_point_motion_hooks
, Qt
);
12434 /* If %c is in the mode line, update it if needed. */
12435 if (!NILP (w
->column_number_displayed
)
12436 /* This alternative quickly identifies a common case
12437 where no change is needed. */
12438 && !(PT
== XFASTINT (w
->last_point
)
12439 && XFASTINT (w
->last_modified
) >= MODIFF
12440 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
12441 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
12442 w
->update_mode_line
= Qt
;
12444 unbind_to (count1
, Qnil
);
12446 FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w
->frame
)) = -1;
12448 /* The variable buffer_shared is set in redisplay_window and
12449 indicates that we redisplay a buffer in different windows. See
12451 consider_all_windows_p
= (update_mode_lines
|| buffer_shared
> 1
12452 || cursor_type_changed
);
12454 /* If specs for an arrow have changed, do thorough redisplay
12455 to ensure we remove any arrow that should no longer exist. */
12456 if (overlay_arrows_changed_p ())
12457 consider_all_windows_p
= windows_or_buffers_changed
= 1;
12459 /* Normally the message* functions will have already displayed and
12460 updated the echo area, but the frame may have been trashed, or
12461 the update may have been preempted, so display the echo area
12462 again here. Checking message_cleared_p captures the case that
12463 the echo area should be cleared. */
12464 if ((!NILP (echo_area_buffer
[0]) && !display_last_displayed_message_p
)
12465 || (!NILP (echo_area_buffer
[1]) && display_last_displayed_message_p
)
12466 || (message_cleared_p
12467 && minibuf_level
== 0
12468 /* If the mini-window is currently selected, this means the
12469 echo-area doesn't show through. */
12470 && !MINI_WINDOW_P (XWINDOW (selected_window
))))
12472 int window_height_changed_p
= echo_area_display (0);
12475 /* If we don't display the current message, don't clear the
12476 message_cleared_p flag, because, if we did, we wouldn't clear
12477 the echo area in the next redisplay which doesn't preserve
12479 if (!display_last_displayed_message_p
)
12480 message_cleared_p
= 0;
12482 if (fonts_changed_p
)
12484 else if (window_height_changed_p
)
12486 consider_all_windows_p
= 1;
12487 ++update_mode_lines
;
12488 ++windows_or_buffers_changed
;
12490 /* If window configuration was changed, frames may have been
12491 marked garbaged. Clear them or we will experience
12492 surprises wrt scrolling. */
12493 if (frame_garbaged
)
12494 clear_garbaged_frames ();
12497 else if (EQ (selected_window
, minibuf_window
)
12498 && (current_buffer
->clip_changed
12499 || XFASTINT (w
->last_modified
) < MODIFF
12500 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
)
12501 && resize_mini_window (w
, 0))
12503 /* Resized active mini-window to fit the size of what it is
12504 showing if its contents might have changed. */
12506 /* FIXME: this causes all frames to be updated, which seems unnecessary
12507 since only the current frame needs to be considered. This function needs
12508 to be rewritten with two variables, consider_all_windows and
12509 consider_all_frames. */
12510 consider_all_windows_p
= 1;
12511 ++windows_or_buffers_changed
;
12512 ++update_mode_lines
;
12514 /* If window configuration was changed, frames may have been
12515 marked garbaged. Clear them or we will experience
12516 surprises wrt scrolling. */
12517 if (frame_garbaged
)
12518 clear_garbaged_frames ();
12522 /* If showing the region, and mark has changed, we must redisplay
12523 the whole window. The assignment to this_line_start_pos prevents
12524 the optimization directly below this if-statement. */
12525 if (((!NILP (Vtransient_mark_mode
)
12526 && !NILP (BVAR (XBUFFER (w
->buffer
), mark_active
)))
12527 != !NILP (w
->region_showing
))
12528 || (!NILP (w
->region_showing
)
12529 && !EQ (w
->region_showing
,
12530 Fmarker_position (BVAR (XBUFFER (w
->buffer
), mark
)))))
12531 CHARPOS (this_line_start_pos
) = 0;
12533 /* Optimize the case that only the line containing the cursor in the
12534 selected window has changed. Variables starting with this_ are
12535 set in display_line and record information about the line
12536 containing the cursor. */
12537 tlbufpos
= this_line_start_pos
;
12538 tlendpos
= this_line_end_pos
;
12539 if (!consider_all_windows_p
12540 && CHARPOS (tlbufpos
) > 0
12541 && NILP (w
->update_mode_line
)
12542 && !current_buffer
->clip_changed
12543 && !current_buffer
->prevent_redisplay_optimizations_p
12544 && FRAME_VISIBLE_P (XFRAME (w
->frame
))
12545 && !FRAME_OBSCURED_P (XFRAME (w
->frame
))
12546 /* Make sure recorded data applies to current buffer, etc. */
12547 && this_line_buffer
== current_buffer
12548 && current_buffer
== XBUFFER (w
->buffer
)
12549 && NILP (w
->force_start
)
12550 && NILP (w
->optional_new_start
)
12551 /* Point must be on the line that we have info recorded about. */
12552 && PT
>= CHARPOS (tlbufpos
)
12553 && PT
<= Z
- CHARPOS (tlendpos
)
12554 /* All text outside that line, including its final newline,
12555 must be unchanged. */
12556 && text_outside_line_unchanged_p (w
, CHARPOS (tlbufpos
),
12557 CHARPOS (tlendpos
)))
12559 if (CHARPOS (tlbufpos
) > BEGV
12560 && FETCH_BYTE (BYTEPOS (tlbufpos
) - 1) != '\n'
12561 && (CHARPOS (tlbufpos
) == ZV
12562 || FETCH_BYTE (BYTEPOS (tlbufpos
)) == '\n'))
12563 /* Former continuation line has disappeared by becoming empty. */
12565 else if (XFASTINT (w
->last_modified
) < MODIFF
12566 || XFASTINT (w
->last_overlay_modified
) < OVERLAY_MODIFF
12567 || MINI_WINDOW_P (w
))
12569 /* We have to handle the case of continuation around a
12570 wide-column character (see the comment in indent.c around
12573 For instance, in the following case:
12575 -------- Insert --------
12576 K_A_N_\\ `a' K_A_N_a\ `X_' are wide-column chars.
12577 J_I_ ==> J_I_ `^^' are cursors.
12581 As we have to redraw the line above, we cannot use this
12585 int line_height_before
= this_line_pixel_height
;
12587 /* Note that start_display will handle the case that the
12588 line starting at tlbufpos is a continuation line. */
12589 start_display (&it
, w
, tlbufpos
);
12591 /* Implementation note: It this still necessary? */
12592 if (it
.current_x
!= this_line_start_x
)
12595 TRACE ((stderr
, "trying display optimization 1\n"));
12596 w
->cursor
.vpos
= -1;
12597 overlay_arrow_seen
= 0;
12598 it
.vpos
= this_line_vpos
;
12599 it
.current_y
= this_line_y
;
12600 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, this_line_vpos
);
12601 display_line (&it
);
12603 /* If line contains point, is not continued,
12604 and ends at same distance from eob as before, we win. */
12605 if (w
->cursor
.vpos
>= 0
12606 /* Line is not continued, otherwise this_line_start_pos
12607 would have been set to 0 in display_line. */
12608 && CHARPOS (this_line_start_pos
)
12609 /* Line ends as before. */
12610 && CHARPOS (this_line_end_pos
) == CHARPOS (tlendpos
)
12611 /* Line has same height as before. Otherwise other lines
12612 would have to be shifted up or down. */
12613 && this_line_pixel_height
== line_height_before
)
12615 /* If this is not the window's last line, we must adjust
12616 the charstarts of the lines below. */
12617 if (it
.current_y
< it
.last_visible_y
)
12619 struct glyph_row
*row
12620 = MATRIX_ROW (w
->current_matrix
, this_line_vpos
+ 1);
12621 EMACS_INT delta
, delta_bytes
;
12623 /* We used to distinguish between two cases here,
12624 conditioned by Z - CHARPOS (tlendpos) == ZV, for
12625 when the line ends in a newline or the end of the
12626 buffer's accessible portion. But both cases did
12627 the same, so they were collapsed. */
12629 - CHARPOS (tlendpos
)
12630 - MATRIX_ROW_START_CHARPOS (row
));
12631 delta_bytes
= (Z_BYTE
12632 - BYTEPOS (tlendpos
)
12633 - MATRIX_ROW_START_BYTEPOS (row
));
12635 increment_matrix_positions (w
->current_matrix
,
12636 this_line_vpos
+ 1,
12637 w
->current_matrix
->nrows
,
12638 delta
, delta_bytes
);
12641 /* If this row displays text now but previously didn't,
12642 or vice versa, w->window_end_vpos may have to be
12644 if ((it
.glyph_row
- 1)->displays_text_p
)
12646 if (XFASTINT (w
->window_end_vpos
) < this_line_vpos
)
12647 XSETINT (w
->window_end_vpos
, this_line_vpos
);
12649 else if (XFASTINT (w
->window_end_vpos
) == this_line_vpos
12650 && this_line_vpos
> 0)
12651 XSETINT (w
->window_end_vpos
, this_line_vpos
- 1);
12652 w
->window_end_valid
= Qnil
;
12654 /* Update hint: No need to try to scroll in update_window. */
12655 w
->desired_matrix
->no_scrolling_p
= 1;
12658 *w
->desired_matrix
->method
= 0;
12659 debug_method_add (w
, "optimization 1");
12661 #ifdef HAVE_WINDOW_SYSTEM
12662 update_window_fringes (w
, 0);
12669 else if (/* Cursor position hasn't changed. */
12670 PT
== XFASTINT (w
->last_point
)
12671 /* Make sure the cursor was last displayed
12672 in this window. Otherwise we have to reposition it. */
12673 && 0 <= w
->cursor
.vpos
12674 && WINDOW_TOTAL_LINES (w
) > w
->cursor
.vpos
)
12678 do_pending_window_change (1);
12679 /* If selected_window changed, redisplay again. */
12680 if (WINDOWP (selected_window
)
12681 && (w
= XWINDOW (selected_window
)) != sw
)
12684 /* We used to always goto end_of_redisplay here, but this
12685 isn't enough if we have a blinking cursor. */
12686 if (w
->cursor_off_p
== w
->last_cursor_off_p
)
12687 goto end_of_redisplay
;
12691 /* If highlighting the region, or if the cursor is in the echo area,
12692 then we can't just move the cursor. */
12693 else if (! (!NILP (Vtransient_mark_mode
)
12694 && !NILP (BVAR (current_buffer
, mark_active
)))
12695 && (EQ (selected_window
, BVAR (current_buffer
, last_selected_window
))
12696 || highlight_nonselected_windows
)
12697 && NILP (w
->region_showing
)
12698 && NILP (Vshow_trailing_whitespace
)
12699 && !cursor_in_echo_area
)
12702 struct glyph_row
*row
;
12704 /* Skip from tlbufpos to PT and see where it is. Note that
12705 PT may be in invisible text. If so, we will end at the
12706 next visible position. */
12707 init_iterator (&it
, w
, CHARPOS (tlbufpos
), BYTEPOS (tlbufpos
),
12708 NULL
, DEFAULT_FACE_ID
);
12709 it
.current_x
= this_line_start_x
;
12710 it
.current_y
= this_line_y
;
12711 it
.vpos
= this_line_vpos
;
12713 /* The call to move_it_to stops in front of PT, but
12714 moves over before-strings. */
12715 move_it_to (&it
, PT
, -1, -1, -1, MOVE_TO_POS
);
12717 if (it
.vpos
== this_line_vpos
12718 && (row
= MATRIX_ROW (w
->current_matrix
, this_line_vpos
),
12721 xassert (this_line_vpos
== it
.vpos
);
12722 xassert (this_line_y
== it
.current_y
);
12723 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
12725 *w
->desired_matrix
->method
= 0;
12726 debug_method_add (w
, "optimization 3");
12735 /* Text changed drastically or point moved off of line. */
12736 SET_MATRIX_ROW_ENABLED_P (w
->desired_matrix
, this_line_vpos
, 0);
12739 CHARPOS (this_line_start_pos
) = 0;
12740 consider_all_windows_p
|= buffer_shared
> 1;
12741 ++clear_face_cache_count
;
12742 #ifdef HAVE_WINDOW_SYSTEM
12743 ++clear_image_cache_count
;
12746 /* Build desired matrices, and update the display. If
12747 consider_all_windows_p is non-zero, do it for all windows on all
12748 frames. Otherwise do it for selected_window, only. */
12750 if (consider_all_windows_p
)
12752 Lisp_Object tail
, frame
;
12754 FOR_EACH_FRAME (tail
, frame
)
12755 XFRAME (frame
)->updated_p
= 0;
12757 /* Recompute # windows showing selected buffer. This will be
12758 incremented each time such a window is displayed. */
12761 FOR_EACH_FRAME (tail
, frame
)
12763 struct frame
*f
= XFRAME (frame
);
12765 if (FRAME_WINDOW_P (f
) || FRAME_TERMCAP_P (f
) || f
== sf
)
12767 if (! EQ (frame
, selected_frame
))
12768 /* Select the frame, for the sake of frame-local
12770 select_frame_for_redisplay (frame
);
12772 /* Mark all the scroll bars to be removed; we'll redeem
12773 the ones we want when we redisplay their windows. */
12774 if (FRAME_TERMINAL (f
)->condemn_scroll_bars_hook
)
12775 FRAME_TERMINAL (f
)->condemn_scroll_bars_hook (f
);
12777 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
12778 redisplay_windows (FRAME_ROOT_WINDOW (f
));
12780 /* The X error handler may have deleted that frame. */
12781 if (!FRAME_LIVE_P (f
))
12784 /* Any scroll bars which redisplay_windows should have
12785 nuked should now go away. */
12786 if (FRAME_TERMINAL (f
)->judge_scroll_bars_hook
)
12787 FRAME_TERMINAL (f
)->judge_scroll_bars_hook (f
);
12789 /* If fonts changed, display again. */
12790 /* ??? rms: I suspect it is a mistake to jump all the way
12791 back to retry here. It should just retry this frame. */
12792 if (fonts_changed_p
)
12795 if (FRAME_VISIBLE_P (f
) && !FRAME_OBSCURED_P (f
))
12797 /* See if we have to hscroll. */
12798 if (!f
->already_hscrolled_p
)
12800 f
->already_hscrolled_p
= 1;
12801 if (hscroll_windows (f
->root_window
))
12805 /* Prevent various kinds of signals during display
12806 update. stdio is not robust about handling
12807 signals, which can cause an apparent I/O
12809 if (interrupt_input
)
12810 unrequest_sigio ();
12813 /* Update the display. */
12814 set_window_update_flags (XWINDOW (f
->root_window
), 1);
12815 pending
|= update_frame (f
, 0, 0);
12821 if (!EQ (old_frame
, selected_frame
)
12822 && FRAME_LIVE_P (XFRAME (old_frame
)))
12823 /* We played a bit fast-and-loose above and allowed selected_frame
12824 and selected_window to be temporarily out-of-sync but let's make
12825 sure this stays contained. */
12826 select_frame_for_redisplay (old_frame
);
12827 eassert (EQ (XFRAME (selected_frame
)->selected_window
, selected_window
));
12831 /* Do the mark_window_display_accurate after all windows have
12832 been redisplayed because this call resets flags in buffers
12833 which are needed for proper redisplay. */
12834 FOR_EACH_FRAME (tail
, frame
)
12836 struct frame
*f
= XFRAME (frame
);
12839 mark_window_display_accurate (f
->root_window
, 1);
12840 if (FRAME_TERMINAL (f
)->frame_up_to_date_hook
)
12841 FRAME_TERMINAL (f
)->frame_up_to_date_hook (f
);
12846 else if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
12848 Lisp_Object mini_window
;
12849 struct frame
*mini_frame
;
12851 displayed_buffer
= XBUFFER (XWINDOW (selected_window
)->buffer
);
12852 /* Use list_of_error, not Qerror, so that
12853 we catch only errors and don't run the debugger. */
12854 internal_condition_case_1 (redisplay_window_1
, selected_window
,
12856 redisplay_window_error
);
12858 /* Compare desired and current matrices, perform output. */
12861 /* If fonts changed, display again. */
12862 if (fonts_changed_p
)
12865 /* Prevent various kinds of signals during display update.
12866 stdio is not robust about handling signals,
12867 which can cause an apparent I/O error. */
12868 if (interrupt_input
)
12869 unrequest_sigio ();
12872 if (FRAME_VISIBLE_P (sf
) && !FRAME_OBSCURED_P (sf
))
12874 if (hscroll_windows (selected_window
))
12877 XWINDOW (selected_window
)->must_be_updated_p
= 1;
12878 pending
= update_frame (sf
, 0, 0);
12881 /* We may have called echo_area_display at the top of this
12882 function. If the echo area is on another frame, that may
12883 have put text on a frame other than the selected one, so the
12884 above call to update_frame would not have caught it. Catch
12886 mini_window
= FRAME_MINIBUF_WINDOW (sf
);
12887 mini_frame
= XFRAME (WINDOW_FRAME (XWINDOW (mini_window
)));
12889 if (mini_frame
!= sf
&& FRAME_WINDOW_P (mini_frame
))
12891 XWINDOW (mini_window
)->must_be_updated_p
= 1;
12892 pending
|= update_frame (mini_frame
, 0, 0);
12893 if (!pending
&& hscroll_windows (mini_window
))
12898 /* If display was paused because of pending input, make sure we do a
12899 thorough update the next time. */
12902 /* Prevent the optimization at the beginning of
12903 redisplay_internal that tries a single-line update of the
12904 line containing the cursor in the selected window. */
12905 CHARPOS (this_line_start_pos
) = 0;
12907 /* Let the overlay arrow be updated the next time. */
12908 update_overlay_arrows (0);
12910 /* If we pause after scrolling, some rows in the current
12911 matrices of some windows are not valid. */
12912 if (!WINDOW_FULL_WIDTH_P (w
)
12913 && !FRAME_WINDOW_P (XFRAME (w
->frame
)))
12914 update_mode_lines
= 1;
12918 if (!consider_all_windows_p
)
12920 /* This has already been done above if
12921 consider_all_windows_p is set. */
12922 mark_window_display_accurate_1 (w
, 1);
12924 /* Say overlay arrows are up to date. */
12925 update_overlay_arrows (1);
12927 if (FRAME_TERMINAL (sf
)->frame_up_to_date_hook
!= 0)
12928 FRAME_TERMINAL (sf
)->frame_up_to_date_hook (sf
);
12931 update_mode_lines
= 0;
12932 windows_or_buffers_changed
= 0;
12933 cursor_type_changed
= 0;
12936 /* Start SIGIO interrupts coming again. Having them off during the
12937 code above makes it less likely one will discard output, but not
12938 impossible, since there might be stuff in the system buffer here.
12939 But it is much hairier to try to do anything about that. */
12940 if (interrupt_input
)
12944 /* If a frame has become visible which was not before, redisplay
12945 again, so that we display it. Expose events for such a frame
12946 (which it gets when becoming visible) don't call the parts of
12947 redisplay constructing glyphs, so simply exposing a frame won't
12948 display anything in this case. So, we have to display these
12949 frames here explicitly. */
12952 Lisp_Object tail
, frame
;
12955 FOR_EACH_FRAME (tail
, frame
)
12957 int this_is_visible
= 0;
12959 if (XFRAME (frame
)->visible
)
12960 this_is_visible
= 1;
12961 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
12962 if (XFRAME (frame
)->visible
)
12963 this_is_visible
= 1;
12965 if (this_is_visible
)
12969 if (new_count
!= number_of_visible_frames
)
12970 windows_or_buffers_changed
++;
12973 /* Change frame size now if a change is pending. */
12974 do_pending_window_change (1);
12976 /* If we just did a pending size change, or have additional
12977 visible frames, or selected_window changed, redisplay again. */
12978 if ((windows_or_buffers_changed
&& !pending
)
12979 || (WINDOWP (selected_window
) && (w
= XWINDOW (selected_window
)) != sw
))
12982 /* Clear the face and image caches.
12984 We used to do this only if consider_all_windows_p. But the cache
12985 needs to be cleared if a timer creates images in the current
12986 buffer (e.g. the test case in Bug#6230). */
12988 if (clear_face_cache_count
> CLEAR_FACE_CACHE_COUNT
)
12990 clear_face_cache (0);
12991 clear_face_cache_count
= 0;
12994 #ifdef HAVE_WINDOW_SYSTEM
12995 if (clear_image_cache_count
> CLEAR_IMAGE_CACHE_COUNT
)
12997 clear_image_caches (Qnil
);
12998 clear_image_cache_count
= 0;
13000 #endif /* HAVE_WINDOW_SYSTEM */
13003 unbind_to (count
, Qnil
);
13008 /* Redisplay, but leave alone any recent echo area message unless
13009 another message has been requested in its place.
13011 This is useful in situations where you need to redisplay but no
13012 user action has occurred, making it inappropriate for the message
13013 area to be cleared. See tracking_off and
13014 wait_reading_process_output for examples of these situations.
13016 FROM_WHERE is an integer saying from where this function was
13017 called. This is useful for debugging. */
13020 redisplay_preserve_echo_area (int from_where
)
13022 TRACE ((stderr
, "redisplay_preserve_echo_area (%d)\n", from_where
));
13024 if (!NILP (echo_area_buffer
[1]))
13026 /* We have a previously displayed message, but no current
13027 message. Redisplay the previous message. */
13028 display_last_displayed_message_p
= 1;
13029 redisplay_internal ();
13030 display_last_displayed_message_p
= 0;
13033 redisplay_internal ();
13035 if (FRAME_RIF (SELECTED_FRAME ()) != NULL
13036 && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional
)
13037 FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL
);
13041 /* Function registered with record_unwind_protect in
13042 redisplay_internal. Reset redisplaying_p to the value it had
13043 before redisplay_internal was called, and clear
13044 prevent_freeing_realized_faces_p. It also selects the previously
13045 selected frame, unless it has been deleted (by an X connection
13046 failure during redisplay, for example). */
13049 unwind_redisplay (Lisp_Object val
)
13051 Lisp_Object old_redisplaying_p
, old_frame
;
13053 old_redisplaying_p
= XCAR (val
);
13054 redisplaying_p
= XFASTINT (old_redisplaying_p
);
13055 old_frame
= XCDR (val
);
13056 if (! EQ (old_frame
, selected_frame
)
13057 && FRAME_LIVE_P (XFRAME (old_frame
)))
13058 select_frame_for_redisplay (old_frame
);
13063 /* Mark the display of window W as accurate or inaccurate. If
13064 ACCURATE_P is non-zero mark display of W as accurate. If
13065 ACCURATE_P is zero, arrange for W to be redisplayed the next time
13066 redisplay_internal is called. */
13069 mark_window_display_accurate_1 (struct window
*w
, int accurate_p
)
13071 if (BUFFERP (w
->buffer
))
13073 struct buffer
*b
= XBUFFER (w
->buffer
);
13076 = make_number (accurate_p
? BUF_MODIFF (b
) : 0);
13077 w
->last_overlay_modified
13078 = make_number (accurate_p
? BUF_OVERLAY_MODIFF (b
) : 0);
13080 = BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
) ? Qt
: Qnil
;
13084 b
->clip_changed
= 0;
13085 b
->prevent_redisplay_optimizations_p
= 0;
13087 BUF_UNCHANGED_MODIFIED (b
) = BUF_MODIFF (b
);
13088 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = BUF_OVERLAY_MODIFF (b
);
13089 BUF_BEG_UNCHANGED (b
) = BUF_GPT (b
) - BUF_BEG (b
);
13090 BUF_END_UNCHANGED (b
) = BUF_Z (b
) - BUF_GPT (b
);
13092 w
->current_matrix
->buffer
= b
;
13093 w
->current_matrix
->begv
= BUF_BEGV (b
);
13094 w
->current_matrix
->zv
= BUF_ZV (b
);
13096 w
->last_cursor
= w
->cursor
;
13097 w
->last_cursor_off_p
= w
->cursor_off_p
;
13099 if (w
== XWINDOW (selected_window
))
13100 w
->last_point
= make_number (BUF_PT (b
));
13102 w
->last_point
= make_number (XMARKER (w
->pointm
)->charpos
);
13108 w
->window_end_valid
= w
->buffer
;
13109 w
->update_mode_line
= Qnil
;
13114 /* Mark the display of windows in the window tree rooted at WINDOW as
13115 accurate or inaccurate. If ACCURATE_P is non-zero mark display of
13116 windows as accurate. If ACCURATE_P is zero, arrange for windows to
13117 be redisplayed the next time redisplay_internal is called. */
13120 mark_window_display_accurate (Lisp_Object window
, int accurate_p
)
13124 for (; !NILP (window
); window
= w
->next
)
13126 w
= XWINDOW (window
);
13127 mark_window_display_accurate_1 (w
, accurate_p
);
13129 if (!NILP (w
->vchild
))
13130 mark_window_display_accurate (w
->vchild
, accurate_p
);
13131 if (!NILP (w
->hchild
))
13132 mark_window_display_accurate (w
->hchild
, accurate_p
);
13137 update_overlay_arrows (1);
13141 /* Force a thorough redisplay the next time by setting
13142 last_arrow_position and last_arrow_string to t, which is
13143 unequal to any useful value of Voverlay_arrow_... */
13144 update_overlay_arrows (-1);
13149 /* Return value in display table DP (Lisp_Char_Table *) for character
13150 C. Since a display table doesn't have any parent, we don't have to
13151 follow parent. Do not call this function directly but use the
13152 macro DISP_CHAR_VECTOR. */
13155 disp_char_vector (struct Lisp_Char_Table
*dp
, int c
)
13159 if (ASCII_CHAR_P (c
))
13162 if (SUB_CHAR_TABLE_P (val
))
13163 val
= XSUB_CHAR_TABLE (val
)->contents
[c
];
13169 XSETCHAR_TABLE (table
, dp
);
13170 val
= char_table_ref (table
, c
);
13179 /***********************************************************************
13181 ***********************************************************************/
13183 /* Redisplay all leaf windows in the window tree rooted at WINDOW. */
13186 redisplay_windows (Lisp_Object window
)
13188 while (!NILP (window
))
13190 struct window
*w
= XWINDOW (window
);
13192 if (!NILP (w
->hchild
))
13193 redisplay_windows (w
->hchild
);
13194 else if (!NILP (w
->vchild
))
13195 redisplay_windows (w
->vchild
);
13196 else if (!NILP (w
->buffer
))
13198 displayed_buffer
= XBUFFER (w
->buffer
);
13199 /* Use list_of_error, not Qerror, so that
13200 we catch only errors and don't run the debugger. */
13201 internal_condition_case_1 (redisplay_window_0
, window
,
13203 redisplay_window_error
);
13211 redisplay_window_error (Lisp_Object ignore
)
13213 displayed_buffer
->display_error_modiff
= BUF_MODIFF (displayed_buffer
);
13218 redisplay_window_0 (Lisp_Object window
)
13220 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13221 redisplay_window (window
, 0);
13226 redisplay_window_1 (Lisp_Object window
)
13228 if (displayed_buffer
->display_error_modiff
< BUF_MODIFF (displayed_buffer
))
13229 redisplay_window (window
, 1);
13234 /* Set cursor position of W. PT is assumed to be displayed in ROW.
13235 DELTA and DELTA_BYTES are the numbers of characters and bytes by
13236 which positions recorded in ROW differ from current buffer
13239 Return 0 if cursor is not on this row, 1 otherwise. */
13242 set_cursor_from_row (struct window
*w
, struct glyph_row
*row
,
13243 struct glyph_matrix
*matrix
,
13244 EMACS_INT delta
, EMACS_INT delta_bytes
,
13247 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
13248 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
13249 struct glyph
*cursor
= NULL
;
13250 /* The last known character position in row. */
13251 EMACS_INT last_pos
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13253 EMACS_INT pt_old
= PT
- delta
;
13254 EMACS_INT pos_before
= MATRIX_ROW_START_CHARPOS (row
) + delta
;
13255 EMACS_INT pos_after
= MATRIX_ROW_END_CHARPOS (row
) + delta
;
13256 struct glyph
*glyph_before
= glyph
- 1, *glyph_after
= end
;
13257 /* A glyph beyond the edge of TEXT_AREA which we should never
13259 struct glyph
*glyphs_end
= end
;
13260 /* Non-zero means we've found a match for cursor position, but that
13261 glyph has the avoid_cursor_p flag set. */
13262 int match_with_avoid_cursor
= 0;
13263 /* Non-zero means we've seen at least one glyph that came from a
13265 int string_seen
= 0;
13266 /* Largest and smalles buffer positions seen so far during scan of
13268 EMACS_INT bpos_max
= pos_before
;
13269 EMACS_INT bpos_min
= pos_after
;
13270 /* Last buffer position covered by an overlay string with an integer
13271 `cursor' property. */
13272 EMACS_INT bpos_covered
= 0;
13274 /* Skip over glyphs not having an object at the start and the end of
13275 the row. These are special glyphs like truncation marks on
13276 terminal frames. */
13277 if (row
->displays_text_p
)
13279 if (!row
->reversed_p
)
13282 && INTEGERP (glyph
->object
)
13283 && glyph
->charpos
< 0)
13285 x
+= glyph
->pixel_width
;
13289 && INTEGERP ((end
- 1)->object
)
13290 /* CHARPOS is zero for blanks and stretch glyphs
13291 inserted by extend_face_to_end_of_line. */
13292 && (end
- 1)->charpos
<= 0)
13294 glyph_before
= glyph
- 1;
13301 /* If the glyph row is reversed, we need to process it from back
13302 to front, so swap the edge pointers. */
13303 glyphs_end
= end
= glyph
- 1;
13304 glyph
+= row
->used
[TEXT_AREA
] - 1;
13306 while (glyph
> end
+ 1
13307 && INTEGERP (glyph
->object
)
13308 && glyph
->charpos
< 0)
13311 x
-= glyph
->pixel_width
;
13313 if (INTEGERP (glyph
->object
) && glyph
->charpos
< 0)
13315 /* By default, in reversed rows we put the cursor on the
13316 rightmost (first in the reading order) glyph. */
13317 for (g
= end
+ 1; g
< glyph
; g
++)
13318 x
+= g
->pixel_width
;
13320 && INTEGERP ((end
+ 1)->object
)
13321 && (end
+ 1)->charpos
<= 0)
13323 glyph_before
= glyph
+ 1;
13327 else if (row
->reversed_p
)
13329 /* In R2L rows that don't display text, put the cursor on the
13330 rightmost glyph. Case in point: an empty last line that is
13331 part of an R2L paragraph. */
13333 /* Avoid placing the cursor on the last glyph of the row, where
13334 on terminal frames we hold the vertical border between
13335 adjacent windows. */
13336 if (!FRAME_WINDOW_P (WINDOW_XFRAME (w
))
13337 && !WINDOW_RIGHTMOST_P (w
)
13338 && cursor
== row
->glyphs
[LAST_AREA
] - 1)
13340 x
= -1; /* will be computed below, at label compute_x */
13343 /* Step 1: Try to find the glyph whose character position
13344 corresponds to point. If that's not possible, find 2 glyphs
13345 whose character positions are the closest to point, one before
13346 point, the other after it. */
13347 if (!row
->reversed_p
)
13348 while (/* not marched to end of glyph row */
13350 /* glyph was not inserted by redisplay for internal purposes */
13351 && !INTEGERP (glyph
->object
))
13353 if (BUFFERP (glyph
->object
))
13355 EMACS_INT dpos
= glyph
->charpos
- pt_old
;
13357 if (glyph
->charpos
> bpos_max
)
13358 bpos_max
= glyph
->charpos
;
13359 if (glyph
->charpos
< bpos_min
)
13360 bpos_min
= glyph
->charpos
;
13361 if (!glyph
->avoid_cursor_p
)
13363 /* If we hit point, we've found the glyph on which to
13364 display the cursor. */
13367 match_with_avoid_cursor
= 0;
13370 /* See if we've found a better approximation to
13371 POS_BEFORE or to POS_AFTER. Note that we want the
13372 first (leftmost) glyph of all those that are the
13373 closest from below, and the last (rightmost) of all
13374 those from above. */
13375 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
13377 pos_before
= glyph
->charpos
;
13378 glyph_before
= glyph
;
13380 else if (0 < dpos
&& dpos
<= pos_after
- pt_old
)
13382 pos_after
= glyph
->charpos
;
13383 glyph_after
= glyph
;
13386 else if (dpos
== 0)
13387 match_with_avoid_cursor
= 1;
13389 else if (STRINGP (glyph
->object
))
13391 Lisp_Object chprop
;
13392 EMACS_INT glyph_pos
= glyph
->charpos
;
13394 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
13396 if (INTEGERP (chprop
))
13398 bpos_covered
= bpos_max
+ XINT (chprop
);
13399 /* If the `cursor' property covers buffer positions up
13400 to and including point, we should display cursor on
13401 this glyph. Note that overlays and text properties
13402 with string values stop bidi reordering, so every
13403 buffer position to the left of the string is always
13404 smaller than any position to the right of the
13405 string. Therefore, if a `cursor' property on one
13406 of the string's characters has an integer value, we
13407 will break out of the loop below _before_ we get to
13408 the position match above. IOW, integer values of
13409 the `cursor' property override the "exact match for
13410 point" strategy of positioning the cursor. */
13411 /* Implementation note: bpos_max == pt_old when, e.g.,
13412 we are in an empty line, where bpos_max is set to
13413 MATRIX_ROW_START_CHARPOS, see above. */
13414 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
13423 x
+= glyph
->pixel_width
;
13426 else if (glyph
> end
) /* row is reversed */
13427 while (!INTEGERP (glyph
->object
))
13429 if (BUFFERP (glyph
->object
))
13431 EMACS_INT dpos
= glyph
->charpos
- pt_old
;
13433 if (glyph
->charpos
> bpos_max
)
13434 bpos_max
= glyph
->charpos
;
13435 if (glyph
->charpos
< bpos_min
)
13436 bpos_min
= glyph
->charpos
;
13437 if (!glyph
->avoid_cursor_p
)
13441 match_with_avoid_cursor
= 0;
13444 if (0 > dpos
&& dpos
> pos_before
- pt_old
)
13446 pos_before
= glyph
->charpos
;
13447 glyph_before
= glyph
;
13449 else if (0 < dpos
&& dpos
<= pos_after
- pt_old
)
13451 pos_after
= glyph
->charpos
;
13452 glyph_after
= glyph
;
13455 else if (dpos
== 0)
13456 match_with_avoid_cursor
= 1;
13458 else if (STRINGP (glyph
->object
))
13460 Lisp_Object chprop
;
13461 EMACS_INT glyph_pos
= glyph
->charpos
;
13463 chprop
= Fget_char_property (make_number (glyph_pos
), Qcursor
,
13465 if (INTEGERP (chprop
))
13467 bpos_covered
= bpos_max
+ XINT (chprop
);
13468 /* If the `cursor' property covers buffer positions up
13469 to and including point, we should display cursor on
13471 if (bpos_max
<= pt_old
&& bpos_covered
>= pt_old
)
13480 if (glyph
== glyphs_end
) /* don't dereference outside TEXT_AREA */
13482 x
--; /* can't use any pixel_width */
13485 x
-= glyph
->pixel_width
;
13488 /* Step 2: If we didn't find an exact match for point, we need to
13489 look for a proper place to put the cursor among glyphs between
13490 GLYPH_BEFORE and GLYPH_AFTER. */
13491 if (!((row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
13492 && BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
13493 && bpos_covered
< pt_old
)
13495 /* An empty line has a single glyph whose OBJECT is zero and
13496 whose CHARPOS is the position of a newline on that line.
13497 Note that on a TTY, there are more glyphs after that, which
13498 were produced by extend_face_to_end_of_line, but their
13499 CHARPOS is zero or negative. */
13501 (row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
)
13502 && INTEGERP (glyph
->object
) && glyph
->charpos
> 0;
13504 if (row
->ends_in_ellipsis_p
&& pos_after
== last_pos
)
13506 EMACS_INT ellipsis_pos
;
13508 /* Scan back over the ellipsis glyphs. */
13509 if (!row
->reversed_p
)
13511 ellipsis_pos
= (glyph
- 1)->charpos
;
13512 while (glyph
> row
->glyphs
[TEXT_AREA
]
13513 && (glyph
- 1)->charpos
== ellipsis_pos
)
13514 glyph
--, x
-= glyph
->pixel_width
;
13515 /* That loop always goes one position too far, including
13516 the glyph before the ellipsis. So scan forward over
13518 x
+= glyph
->pixel_width
;
13521 else /* row is reversed */
13523 ellipsis_pos
= (glyph
+ 1)->charpos
;
13524 while (glyph
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1
13525 && (glyph
+ 1)->charpos
== ellipsis_pos
)
13526 glyph
++, x
+= glyph
->pixel_width
;
13527 x
-= glyph
->pixel_width
;
13531 else if (match_with_avoid_cursor
13532 /* A truncated row may not include PT among its
13533 character positions. Setting the cursor inside the
13534 scroll margin will trigger recalculation of hscroll
13535 in hscroll_window_tree. */
13536 || (row
->truncated_on_left_p
&& pt_old
< bpos_min
)
13537 || (row
->truncated_on_right_p
&& pt_old
> bpos_max
)
13538 /* Zero-width characters produce no glyphs. */
13541 && (row
->reversed_p
13542 ? glyph_after
> glyphs_end
13543 : glyph_after
< glyphs_end
)))
13545 cursor
= glyph_after
;
13548 else if (string_seen
)
13550 int incr
= row
->reversed_p
? -1 : +1;
13552 /* Need to find the glyph that came out of a string which is
13553 present at point. That glyph is somewhere between
13554 GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
13555 positioned between POS_BEFORE and POS_AFTER in the
13557 struct glyph
*start
, *stop
;
13558 EMACS_INT pos
= pos_before
;
13562 /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
13563 correspond to POS_BEFORE and POS_AFTER, respectively. We
13564 need START and STOP in the order that corresponds to the
13565 row's direction as given by its reversed_p flag. If the
13566 directionality of characters between POS_BEFORE and
13567 POS_AFTER is the opposite of the row's base direction,
13568 these characters will have been reordered for display,
13569 and we need to reverse START and STOP. */
13570 if (!row
->reversed_p
)
13572 start
= min (glyph_before
, glyph_after
);
13573 stop
= max (glyph_before
, glyph_after
);
13577 start
= max (glyph_before
, glyph_after
);
13578 stop
= min (glyph_before
, glyph_after
);
13580 for (glyph
= start
+ incr
;
13581 row
->reversed_p
? glyph
> stop
: glyph
< stop
; )
13584 /* Any glyphs that come from the buffer are here because
13585 of bidi reordering. Skip them, and only pay
13586 attention to glyphs that came from some string. */
13587 if (STRINGP (glyph
->object
))
13592 str
= glyph
->object
;
13593 tem
= string_buffer_position_lim (str
, pos
, pos_after
, 0);
13594 if (tem
== 0 /* from overlay */
13597 /* If the string from which this glyph came is
13598 found in the buffer at point, then we've
13599 found the glyph we've been looking for. If
13600 it comes from an overlay (tem == 0), and it
13601 has the `cursor' property on one of its
13602 glyphs, record that glyph as a candidate for
13603 displaying the cursor. (As in the
13604 unidirectional version, we will display the
13605 cursor on the last candidate we find.) */
13606 if (tem
== 0 || tem
== pt_old
)
13608 /* The glyphs from this string could have
13609 been reordered. Find the one with the
13610 smallest string position. Or there could
13611 be a character in the string with the
13612 `cursor' property, which means display
13613 cursor on that character's glyph. */
13614 EMACS_INT strpos
= glyph
->charpos
;
13619 (row
->reversed_p
? glyph
> stop
: glyph
< stop
)
13620 && EQ (glyph
->object
, str
);
13624 EMACS_INT gpos
= glyph
->charpos
;
13626 cprop
= Fget_char_property (make_number (gpos
),
13634 if (tem
&& glyph
->charpos
< strpos
)
13636 strpos
= glyph
->charpos
;
13645 pos
= tem
+ 1; /* don't find previous instances */
13647 /* This string is not what we want; skip all of the
13648 glyphs that came from it. */
13649 while ((row
->reversed_p
? glyph
> stop
: glyph
< stop
)
13650 && EQ (glyph
->object
, str
))
13657 /* If we reached the end of the line, and END was from a string,
13658 the cursor is not on this line. */
13660 && (row
->reversed_p
? glyph
<= end
: glyph
>= end
)
13661 && STRINGP (end
->object
)
13662 && row
->continued_p
)
13668 if (cursor
!= NULL
)
13674 /* Need to compute x that corresponds to GLYPH. */
13675 for (g
= row
->glyphs
[TEXT_AREA
], x
= row
->x
; g
< glyph
; g
++)
13677 if (g
>= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
])
13679 x
+= g
->pixel_width
;
13683 /* ROW could be part of a continued line, which, under bidi
13684 reordering, might have other rows whose start and end charpos
13685 occlude point. Only set w->cursor if we found a better
13686 approximation to the cursor position than we have from previously
13687 examined candidate rows belonging to the same continued line. */
13688 if (/* we already have a candidate row */
13689 w
->cursor
.vpos
>= 0
13690 /* that candidate is not the row we are processing */
13691 && MATRIX_ROW (matrix
, w
->cursor
.vpos
) != row
13692 /* the row we are processing is part of a continued line */
13693 && (row
->continued_p
|| MATRIX_ROW_CONTINUATION_LINE_P (row
))
13694 /* Make sure cursor.vpos specifies a row whose start and end
13695 charpos occlude point. This is because some callers of this
13696 function leave cursor.vpos at the row where the cursor was
13697 displayed during the last redisplay cycle. */
13698 && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)) <= pt_old
13699 && pt_old
< MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
)))
13702 MATRIX_ROW_GLYPH_START (matrix
, w
->cursor
.vpos
) + w
->cursor
.hpos
;
13704 /* Don't consider glyphs that are outside TEXT_AREA. */
13705 if (!(row
->reversed_p
? glyph
> glyphs_end
: glyph
< glyphs_end
))
13707 /* Keep the candidate whose buffer position is the closest to
13709 if (/* previous candidate is a glyph in TEXT_AREA of that row */
13710 w
->cursor
.hpos
>= 0
13711 && w
->cursor
.hpos
< MATRIX_ROW_USED (matrix
, w
->cursor
.vpos
)
13712 && BUFFERP (g1
->object
)
13713 && (g1
->charpos
== pt_old
/* an exact match always wins */
13714 || (BUFFERP (glyph
->object
)
13715 && eabs (g1
->charpos
- pt_old
)
13716 < eabs (glyph
->charpos
- pt_old
))))
13718 /* If this candidate gives an exact match, use that. */
13719 if (!(BUFFERP (glyph
->object
) && glyph
->charpos
== pt_old
)
13720 /* Otherwise, keep the candidate that comes from a row
13721 spanning less buffer positions. This may win when one or
13722 both candidate positions are on glyphs that came from
13723 display strings, for which we cannot compare buffer
13725 && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
13726 - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix
, w
->cursor
.vpos
))
13727 < MATRIX_ROW_END_CHARPOS (row
) - MATRIX_ROW_START_CHARPOS (row
))
13730 w
->cursor
.hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
13732 w
->cursor
.vpos
= MATRIX_ROW_VPOS (row
, matrix
) + dvpos
;
13733 w
->cursor
.y
= row
->y
+ dy
;
13735 if (w
== XWINDOW (selected_window
))
13737 if (!row
->continued_p
13738 && !MATRIX_ROW_CONTINUATION_LINE_P (row
)
13741 this_line_buffer
= XBUFFER (w
->buffer
);
13743 CHARPOS (this_line_start_pos
)
13744 = MATRIX_ROW_START_CHARPOS (row
) + delta
;
13745 BYTEPOS (this_line_start_pos
)
13746 = MATRIX_ROW_START_BYTEPOS (row
) + delta_bytes
;
13748 CHARPOS (this_line_end_pos
)
13749 = Z
- (MATRIX_ROW_END_CHARPOS (row
) + delta
);
13750 BYTEPOS (this_line_end_pos
)
13751 = Z_BYTE
- (MATRIX_ROW_END_BYTEPOS (row
) + delta_bytes
);
13753 this_line_y
= w
->cursor
.y
;
13754 this_line_pixel_height
= row
->height
;
13755 this_line_vpos
= w
->cursor
.vpos
;
13756 this_line_start_x
= row
->x
;
13759 CHARPOS (this_line_start_pos
) = 0;
13766 /* Run window scroll functions, if any, for WINDOW with new window
13767 start STARTP. Sets the window start of WINDOW to that position.
13769 We assume that the window's buffer is really current. */
13771 static INLINE
struct text_pos
13772 run_window_scroll_functions (Lisp_Object window
, struct text_pos startp
)
13774 struct window
*w
= XWINDOW (window
);
13775 SET_MARKER_FROM_TEXT_POS (w
->start
, startp
);
13777 if (current_buffer
!= XBUFFER (w
->buffer
))
13780 if (!NILP (Vwindow_scroll_functions
))
13782 run_hook_with_args_2 (Qwindow_scroll_functions
, window
,
13783 make_number (CHARPOS (startp
)));
13784 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13785 /* In case the hook functions switch buffers. */
13786 if (current_buffer
!= XBUFFER (w
->buffer
))
13787 set_buffer_internal_1 (XBUFFER (w
->buffer
));
13794 /* Make sure the line containing the cursor is fully visible.
13795 A value of 1 means there is nothing to be done.
13796 (Either the line is fully visible, or it cannot be made so,
13797 or we cannot tell.)
13799 If FORCE_P is non-zero, return 0 even if partial visible cursor row
13800 is higher than window.
13802 A value of 0 means the caller should do scrolling
13803 as if point had gone off the screen. */
13806 cursor_row_fully_visible_p (struct window
*w
, int force_p
, int current_matrix_p
)
13808 struct glyph_matrix
*matrix
;
13809 struct glyph_row
*row
;
13812 if (!make_cursor_line_fully_visible_p
)
13815 /* It's not always possible to find the cursor, e.g, when a window
13816 is full of overlay strings. Don't do anything in that case. */
13817 if (w
->cursor
.vpos
< 0)
13820 matrix
= current_matrix_p
? w
->current_matrix
: w
->desired_matrix
;
13821 row
= MATRIX_ROW (matrix
, w
->cursor
.vpos
);
13823 /* If the cursor row is not partially visible, there's nothing to do. */
13824 if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
))
13827 /* If the row the cursor is in is taller than the window's height,
13828 it's not clear what to do, so do nothing. */
13829 window_height
= window_box_height (w
);
13830 if (row
->height
>= window_height
)
13832 if (!force_p
|| MINI_WINDOW_P (w
)
13833 || w
->vscroll
|| w
->cursor
.vpos
== 0)
13840 /* Try scrolling PT into view in window WINDOW. JUST_THIS_ONE_P
13841 non-zero means only WINDOW is redisplayed in redisplay_internal.
13842 TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
13843 in redisplay_window to bring a partially visible line into view in
13844 the case that only the cursor has moved.
13846 LAST_LINE_MISFIT should be nonzero if we're scrolling because the
13847 last screen line's vertical height extends past the end of the screen.
13851 1 if scrolling succeeded
13853 0 if scrolling didn't find point.
13855 -1 if new fonts have been loaded so that we must interrupt
13856 redisplay, adjust glyph matrices, and try again. */
13862 SCROLLING_NEED_LARGER_MATRICES
13865 /* If scroll-conservatively is more than this, never recenter.
13867 If you change this, don't forget to update the doc string of
13868 `scroll-conservatively' and the Emacs manual. */
13869 #define SCROLL_LIMIT 100
13872 try_scrolling (Lisp_Object window
, int just_this_one_p
,
13873 EMACS_INT arg_scroll_conservatively
, EMACS_INT scroll_step
,
13874 int temp_scroll_step
, int last_line_misfit
)
13876 struct window
*w
= XWINDOW (window
);
13877 struct frame
*f
= XFRAME (w
->frame
);
13878 struct text_pos pos
, startp
;
13880 int this_scroll_margin
, scroll_max
, rc
, height
;
13881 int dy
= 0, amount_to_scroll
= 0, scroll_down_p
= 0;
13882 int extra_scroll_margin_lines
= last_line_misfit
? 1 : 0;
13883 Lisp_Object aggressive
;
13884 /* We will never try scrolling more than this number of lines. */
13885 int scroll_limit
= SCROLL_LIMIT
;
13888 debug_method_add (w
, "try_scrolling");
13891 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
13893 /* Compute scroll margin height in pixels. We scroll when point is
13894 within this distance from the top or bottom of the window. */
13895 if (scroll_margin
> 0)
13896 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
13897 * FRAME_LINE_HEIGHT (f
);
13899 this_scroll_margin
= 0;
13901 /* Force arg_scroll_conservatively to have a reasonable value, to
13902 avoid scrolling too far away with slow move_it_* functions. Note
13903 that the user can supply scroll-conservatively equal to
13904 `most-positive-fixnum', which can be larger than INT_MAX. */
13905 if (arg_scroll_conservatively
> scroll_limit
)
13907 arg_scroll_conservatively
= scroll_limit
+ 1;
13908 scroll_max
= scroll_limit
* FRAME_LINE_HEIGHT (f
);
13910 else if (scroll_step
|| arg_scroll_conservatively
|| temp_scroll_step
)
13911 /* Compute how much we should try to scroll maximally to bring
13912 point into view. */
13913 scroll_max
= (max (scroll_step
,
13914 max (arg_scroll_conservatively
, temp_scroll_step
))
13915 * FRAME_LINE_HEIGHT (f
));
13916 else if (NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
))
13917 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
)))
13918 /* We're trying to scroll because of aggressive scrolling but no
13919 scroll_step is set. Choose an arbitrary one. */
13920 scroll_max
= 10 * FRAME_LINE_HEIGHT (f
);
13926 /* Decide whether to scroll down. */
13927 if (PT
> CHARPOS (startp
))
13929 int scroll_margin_y
;
13931 /* Compute the pixel ypos of the scroll margin, then move it to
13932 either that ypos or PT, whichever comes first. */
13933 start_display (&it
, w
, startp
);
13934 scroll_margin_y
= it
.last_visible_y
- this_scroll_margin
13935 - FRAME_LINE_HEIGHT (f
) * extra_scroll_margin_lines
;
13936 move_it_to (&it
, PT
, -1, scroll_margin_y
- 1, -1,
13937 (MOVE_TO_POS
| MOVE_TO_Y
));
13939 if (PT
> CHARPOS (it
.current
.pos
))
13941 int y0
= line_bottom_y (&it
);
13942 /* Compute how many pixels below window bottom to stop searching
13943 for PT. This avoids costly search for PT that is far away if
13944 the user limited scrolling by a small number of lines, but
13945 always finds PT if scroll_conservatively is set to a large
13946 number, such as most-positive-fixnum. */
13947 int slack
= max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
));
13948 int y_to_move
= it
.last_visible_y
+ slack
;
13950 /* Compute the distance from the scroll margin to PT or to
13951 the scroll limit, whichever comes first. This should
13952 include the height of the cursor line, to make that line
13954 move_it_to (&it
, PT
, -1, y_to_move
,
13955 -1, MOVE_TO_POS
| MOVE_TO_Y
);
13956 dy
= line_bottom_y (&it
) - y0
;
13958 if (dy
> scroll_max
)
13959 return SCROLLING_FAILED
;
13967 /* Point is in or below the bottom scroll margin, so move the
13968 window start down. If scrolling conservatively, move it just
13969 enough down to make point visible. If scroll_step is set,
13970 move it down by scroll_step. */
13971 if (arg_scroll_conservatively
)
13973 = min (max (dy
, FRAME_LINE_HEIGHT (f
)),
13974 FRAME_LINE_HEIGHT (f
) * arg_scroll_conservatively
);
13975 else if (scroll_step
|| temp_scroll_step
)
13976 amount_to_scroll
= scroll_max
;
13979 aggressive
= BVAR (current_buffer
, scroll_up_aggressively
);
13980 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
13981 if (NUMBERP (aggressive
))
13983 double float_amount
= XFLOATINT (aggressive
) * height
;
13984 amount_to_scroll
= float_amount
;
13985 if (amount_to_scroll
== 0 && float_amount
> 0)
13986 amount_to_scroll
= 1;
13987 /* Don't let point enter the scroll margin near top of
13989 if (amount_to_scroll
> height
- 2*this_scroll_margin
+ dy
)
13990 amount_to_scroll
= height
- 2*this_scroll_margin
+ dy
;
13994 if (amount_to_scroll
<= 0)
13995 return SCROLLING_FAILED
;
13997 start_display (&it
, w
, startp
);
13998 if (arg_scroll_conservatively
<= scroll_limit
)
13999 move_it_vertically (&it
, amount_to_scroll
);
14002 /* Extra precision for users who set scroll-conservatively
14003 to a large number: make sure the amount we scroll
14004 the window start is never less than amount_to_scroll,
14005 which was computed as distance from window bottom to
14006 point. This matters when lines at window top and lines
14007 below window bottom have different height. */
14009 void *it1data
= NULL
;
14010 /* We use a temporary it1 because line_bottom_y can modify
14011 its argument, if it moves one line down; see there. */
14014 SAVE_IT (it1
, it
, it1data
);
14015 start_y
= line_bottom_y (&it1
);
14017 RESTORE_IT (&it
, &it
, it1data
);
14018 move_it_by_lines (&it
, 1);
14019 SAVE_IT (it1
, it
, it1data
);
14020 } while (line_bottom_y (&it1
) - start_y
< amount_to_scroll
);
14023 /* If STARTP is unchanged, move it down another screen line. */
14024 if (CHARPOS (it
.current
.pos
) == CHARPOS (startp
))
14025 move_it_by_lines (&it
, 1);
14026 startp
= it
.current
.pos
;
14030 struct text_pos scroll_margin_pos
= startp
;
14032 /* See if point is inside the scroll margin at the top of the
14034 if (this_scroll_margin
)
14036 start_display (&it
, w
, startp
);
14037 move_it_vertically (&it
, this_scroll_margin
);
14038 scroll_margin_pos
= it
.current
.pos
;
14041 if (PT
< CHARPOS (scroll_margin_pos
))
14043 /* Point is in the scroll margin at the top of the window or
14044 above what is displayed in the window. */
14047 /* Compute the vertical distance from PT to the scroll
14048 margin position. Move as far as scroll_max allows, or
14049 one screenful, or 10 screen lines, whichever is largest.
14050 Give up if distance is greater than scroll_max. */
14051 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
14052 start_display (&it
, w
, pos
);
14054 y_to_move
= max (it
.last_visible_y
,
14055 max (scroll_max
, 10 * FRAME_LINE_HEIGHT (f
)));
14056 move_it_to (&it
, CHARPOS (scroll_margin_pos
), 0,
14058 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
14059 dy
= it
.current_y
- y0
;
14060 if (dy
> scroll_max
)
14061 return SCROLLING_FAILED
;
14063 /* Compute new window start. */
14064 start_display (&it
, w
, startp
);
14066 if (arg_scroll_conservatively
)
14067 amount_to_scroll
= max (dy
, FRAME_LINE_HEIGHT (f
) *
14068 max (scroll_step
, temp_scroll_step
));
14069 else if (scroll_step
|| temp_scroll_step
)
14070 amount_to_scroll
= scroll_max
;
14073 aggressive
= BVAR (current_buffer
, scroll_down_aggressively
);
14074 height
= WINDOW_BOX_TEXT_HEIGHT (w
);
14075 if (NUMBERP (aggressive
))
14077 double float_amount
= XFLOATINT (aggressive
) * height
;
14078 amount_to_scroll
= float_amount
;
14079 if (amount_to_scroll
== 0 && float_amount
> 0)
14080 amount_to_scroll
= 1;
14081 amount_to_scroll
-=
14082 this_scroll_margin
- dy
- FRAME_LINE_HEIGHT (f
);
14083 /* Don't let point enter the scroll margin near
14084 bottom of the window. */
14085 if (amount_to_scroll
> height
- 2*this_scroll_margin
+ dy
)
14086 amount_to_scroll
= height
- 2*this_scroll_margin
+ dy
;
14090 if (amount_to_scroll
<= 0)
14091 return SCROLLING_FAILED
;
14093 move_it_vertically_backward (&it
, amount_to_scroll
);
14094 startp
= it
.current
.pos
;
14098 /* Run window scroll functions. */
14099 startp
= run_window_scroll_functions (window
, startp
);
14101 /* Display the window. Give up if new fonts are loaded, or if point
14103 if (!try_window (window
, startp
, 0))
14104 rc
= SCROLLING_NEED_LARGER_MATRICES
;
14105 else if (w
->cursor
.vpos
< 0)
14107 clear_glyph_matrix (w
->desired_matrix
);
14108 rc
= SCROLLING_FAILED
;
14112 /* Maybe forget recorded base line for line number display. */
14113 if (!just_this_one_p
14114 || current_buffer
->clip_changed
14115 || BEG_UNCHANGED
< CHARPOS (startp
))
14116 w
->base_line_number
= Qnil
;
14118 /* If cursor ends up on a partially visible line,
14119 treat that as being off the bottom of the screen. */
14120 if (! cursor_row_fully_visible_p (w
, extra_scroll_margin_lines
<= 1, 0)
14121 /* It's possible that the cursor is on the first line of the
14122 buffer, which is partially obscured due to a vscroll
14123 (Bug#7537). In that case, avoid looping forever . */
14124 && extra_scroll_margin_lines
< w
->desired_matrix
->nrows
- 1)
14126 clear_glyph_matrix (w
->desired_matrix
);
14127 ++extra_scroll_margin_lines
;
14130 rc
= SCROLLING_SUCCESS
;
14137 /* Compute a suitable window start for window W if display of W starts
14138 on a continuation line. Value is non-zero if a new window start
14141 The new window start will be computed, based on W's width, starting
14142 from the start of the continued line. It is the start of the
14143 screen line with the minimum distance from the old start W->start. */
14146 compute_window_start_on_continuation_line (struct window
*w
)
14148 struct text_pos pos
, start_pos
;
14149 int window_start_changed_p
= 0;
14151 SET_TEXT_POS_FROM_MARKER (start_pos
, w
->start
);
14153 /* If window start is on a continuation line... Window start may be
14154 < BEGV in case there's invisible text at the start of the
14155 buffer (M-x rmail, for example). */
14156 if (CHARPOS (start_pos
) > BEGV
14157 && FETCH_BYTE (BYTEPOS (start_pos
) - 1) != '\n')
14160 struct glyph_row
*row
;
14162 /* Handle the case that the window start is out of range. */
14163 if (CHARPOS (start_pos
) < BEGV
)
14164 SET_TEXT_POS (start_pos
, BEGV
, BEGV_BYTE
);
14165 else if (CHARPOS (start_pos
) > ZV
)
14166 SET_TEXT_POS (start_pos
, ZV
, ZV_BYTE
);
14168 /* Find the start of the continued line. This should be fast
14169 because scan_buffer is fast (newline cache). */
14170 row
= w
->desired_matrix
->rows
+ (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0);
14171 init_iterator (&it
, w
, CHARPOS (start_pos
), BYTEPOS (start_pos
),
14172 row
, DEFAULT_FACE_ID
);
14173 reseat_at_previous_visible_line_start (&it
);
14175 /* If the line start is "too far" away from the window start,
14176 say it takes too much time to compute a new window start. */
14177 if (CHARPOS (start_pos
) - IT_CHARPOS (it
)
14178 < WINDOW_TOTAL_LINES (w
) * WINDOW_TOTAL_COLS (w
))
14180 int min_distance
, distance
;
14182 /* Move forward by display lines to find the new window
14183 start. If window width was enlarged, the new start can
14184 be expected to be > the old start. If window width was
14185 decreased, the new window start will be < the old start.
14186 So, we're looking for the display line start with the
14187 minimum distance from the old window start. */
14188 pos
= it
.current
.pos
;
14189 min_distance
= INFINITY
;
14190 while ((distance
= eabs (CHARPOS (start_pos
) - IT_CHARPOS (it
))),
14191 distance
< min_distance
)
14193 min_distance
= distance
;
14194 pos
= it
.current
.pos
;
14195 move_it_by_lines (&it
, 1);
14198 /* Set the window start there. */
14199 SET_MARKER_FROM_TEXT_POS (w
->start
, pos
);
14200 window_start_changed_p
= 1;
14204 return window_start_changed_p
;
14208 /* Try cursor movement in case text has not changed in window WINDOW,
14209 with window start STARTP. Value is
14211 CURSOR_MOVEMENT_SUCCESS if successful
14213 CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
14215 CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
14216 display. *SCROLL_STEP is set to 1, under certain circumstances, if
14217 we want to scroll as if scroll-step were set to 1. See the code.
14219 CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
14220 which case we have to abort this redisplay, and adjust matrices
14225 CURSOR_MOVEMENT_SUCCESS
,
14226 CURSOR_MOVEMENT_CANNOT_BE_USED
,
14227 CURSOR_MOVEMENT_MUST_SCROLL
,
14228 CURSOR_MOVEMENT_NEED_LARGER_MATRICES
14232 try_cursor_movement (Lisp_Object window
, struct text_pos startp
, int *scroll_step
)
14234 struct window
*w
= XWINDOW (window
);
14235 struct frame
*f
= XFRAME (w
->frame
);
14236 int rc
= CURSOR_MOVEMENT_CANNOT_BE_USED
;
14239 if (inhibit_try_cursor_movement
)
14243 /* Handle case where text has not changed, only point, and it has
14244 not moved off the frame. */
14245 if (/* Point may be in this window. */
14246 PT
>= CHARPOS (startp
)
14247 /* Selective display hasn't changed. */
14248 && !current_buffer
->clip_changed
14249 /* Function force-mode-line-update is used to force a thorough
14250 redisplay. It sets either windows_or_buffers_changed or
14251 update_mode_lines. So don't take a shortcut here for these
14253 && !update_mode_lines
14254 && !windows_or_buffers_changed
14255 && !cursor_type_changed
14256 /* Can't use this case if highlighting a region. When a
14257 region exists, cursor movement has to do more than just
14259 && !(!NILP (Vtransient_mark_mode
)
14260 && !NILP (BVAR (current_buffer
, mark_active
)))
14261 && NILP (w
->region_showing
)
14262 && NILP (Vshow_trailing_whitespace
)
14263 /* Right after splitting windows, last_point may be nil. */
14264 && INTEGERP (w
->last_point
)
14265 /* This code is not used for mini-buffer for the sake of the case
14266 of redisplaying to replace an echo area message; since in
14267 that case the mini-buffer contents per se are usually
14268 unchanged. This code is of no real use in the mini-buffer
14269 since the handling of this_line_start_pos, etc., in redisplay
14270 handles the same cases. */
14271 && !EQ (window
, minibuf_window
)
14272 /* When splitting windows or for new windows, it happens that
14273 redisplay is called with a nil window_end_vpos or one being
14274 larger than the window. This should really be fixed in
14275 window.c. I don't have this on my list, now, so we do
14276 approximately the same as the old redisplay code. --gerd. */
14277 && INTEGERP (w
->window_end_vpos
)
14278 && XFASTINT (w
->window_end_vpos
) < w
->current_matrix
->nrows
14279 && (FRAME_WINDOW_P (f
)
14280 || !overlay_arrow_in_current_buffer_p ()))
14282 int this_scroll_margin
, top_scroll_margin
;
14283 struct glyph_row
*row
= NULL
;
14286 debug_method_add (w
, "cursor movement");
14289 /* Scroll if point within this distance from the top or bottom
14290 of the window. This is a pixel value. */
14291 if (scroll_margin
> 0)
14293 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
14294 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
14297 this_scroll_margin
= 0;
14299 top_scroll_margin
= this_scroll_margin
;
14300 if (WINDOW_WANTS_HEADER_LINE_P (w
))
14301 top_scroll_margin
+= CURRENT_HEADER_LINE_HEIGHT (w
);
14303 /* Start with the row the cursor was displayed during the last
14304 not paused redisplay. Give up if that row is not valid. */
14305 if (w
->last_cursor
.vpos
< 0
14306 || w
->last_cursor
.vpos
>= w
->current_matrix
->nrows
)
14307 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14310 row
= MATRIX_ROW (w
->current_matrix
, w
->last_cursor
.vpos
);
14311 if (row
->mode_line_p
)
14313 if (!row
->enabled_p
)
14314 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14317 if (rc
== CURSOR_MOVEMENT_CANNOT_BE_USED
)
14319 int scroll_p
= 0, must_scroll
= 0;
14320 int last_y
= window_text_bottom_y (w
) - this_scroll_margin
;
14322 if (PT
> XFASTINT (w
->last_point
))
14324 /* Point has moved forward. */
14325 while (MATRIX_ROW_END_CHARPOS (row
) < PT
14326 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
)
14328 xassert (row
->enabled_p
);
14332 /* If the end position of a row equals the start
14333 position of the next row, and PT is at that position,
14334 we would rather display cursor in the next line. */
14335 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
14336 && MATRIX_ROW_END_CHARPOS (row
) == PT
14337 && row
< w
->current_matrix
->rows
14338 + w
->current_matrix
->nrows
- 1
14339 && MATRIX_ROW_START_CHARPOS (row
+1) == PT
14340 && !cursor_row_p (row
))
14343 /* If within the scroll margin, scroll. Note that
14344 MATRIX_ROW_BOTTOM_Y gives the pixel position at which
14345 the next line would be drawn, and that
14346 this_scroll_margin can be zero. */
14347 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
14348 || PT
> MATRIX_ROW_END_CHARPOS (row
)
14349 /* Line is completely visible last line in window
14350 and PT is to be set in the next line. */
14351 || (MATRIX_ROW_BOTTOM_Y (row
) == last_y
14352 && PT
== MATRIX_ROW_END_CHARPOS (row
)
14353 && !row
->ends_at_zv_p
14354 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
14357 else if (PT
< XFASTINT (w
->last_point
))
14359 /* Cursor has to be moved backward. Note that PT >=
14360 CHARPOS (startp) because of the outer if-statement. */
14361 while (!row
->mode_line_p
14362 && (MATRIX_ROW_START_CHARPOS (row
) > PT
14363 || (MATRIX_ROW_START_CHARPOS (row
) == PT
14364 && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row
)
14365 || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
14366 row
> w
->current_matrix
->rows
14367 && (row
-1)->ends_in_newline_from_string_p
))))
14368 && (row
->y
> top_scroll_margin
14369 || CHARPOS (startp
) == BEGV
))
14371 xassert (row
->enabled_p
);
14375 /* Consider the following case: Window starts at BEGV,
14376 there is invisible, intangible text at BEGV, so that
14377 display starts at some point START > BEGV. It can
14378 happen that we are called with PT somewhere between
14379 BEGV and START. Try to handle that case. */
14380 if (row
< w
->current_matrix
->rows
14381 || row
->mode_line_p
)
14383 row
= w
->current_matrix
->rows
;
14384 if (row
->mode_line_p
)
14388 /* Due to newlines in overlay strings, we may have to
14389 skip forward over overlay strings. */
14390 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
14391 && MATRIX_ROW_END_CHARPOS (row
) == PT
14392 && !cursor_row_p (row
))
14395 /* If within the scroll margin, scroll. */
14396 if (row
->y
< top_scroll_margin
14397 && CHARPOS (startp
) != BEGV
)
14402 /* Cursor did not move. So don't scroll even if cursor line
14403 is partially visible, as it was so before. */
14404 rc
= CURSOR_MOVEMENT_SUCCESS
;
14407 if (PT
< MATRIX_ROW_START_CHARPOS (row
)
14408 || PT
> MATRIX_ROW_END_CHARPOS (row
))
14410 /* if PT is not in the glyph row, give up. */
14411 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14414 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
14415 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
14417 /* If rows are bidi-reordered and point moved, back up
14418 until we find a row that does not belong to a
14419 continuation line. This is because we must consider
14420 all rows of a continued line as candidates for the
14421 new cursor positioning, since row start and end
14422 positions change non-linearly with vertical position
14424 /* FIXME: Revisit this when glyph ``spilling'' in
14425 continuation lines' rows is implemented for
14426 bidi-reordered rows. */
14427 while (MATRIX_ROW_CONTINUATION_LINE_P (row
))
14429 xassert (row
->enabled_p
);
14431 /* If we hit the beginning of the displayed portion
14432 without finding the first row of a continued
14434 if (row
<= w
->current_matrix
->rows
)
14436 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14444 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
14445 && MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, row
)
14446 && make_cursor_line_fully_visible_p
)
14448 if (PT
== MATRIX_ROW_END_CHARPOS (row
)
14449 && !row
->ends_at_zv_p
14450 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
14451 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14452 else if (row
->height
> window_box_height (w
))
14454 /* If we end up in a partially visible line, let's
14455 make it fully visible, except when it's taller
14456 than the window, in which case we can't do much
14459 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14463 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
14464 if (!cursor_row_fully_visible_p (w
, 0, 1))
14465 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14467 rc
= CURSOR_MOVEMENT_SUCCESS
;
14471 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14472 else if (rc
!= CURSOR_MOVEMENT_SUCCESS
14473 && !NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
14475 /* With bidi-reordered rows, there could be more than
14476 one candidate row whose start and end positions
14477 occlude point. We need to let set_cursor_from_row
14478 find the best candidate. */
14479 /* FIXME: Revisit this when glyph ``spilling'' in
14480 continuation lines' rows is implemented for
14481 bidi-reordered rows. */
14486 if (MATRIX_ROW_START_CHARPOS (row
) <= PT
14487 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
14488 && cursor_row_p (row
))
14489 rv
|= set_cursor_from_row (w
, row
, w
->current_matrix
,
14491 /* As soon as we've found the first suitable row
14492 whose ends_at_zv_p flag is set, we are done. */
14494 && MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
)->ends_at_zv_p
)
14496 rc
= CURSOR_MOVEMENT_SUCCESS
;
14501 while ((MATRIX_ROW_CONTINUATION_LINE_P (row
)
14502 && MATRIX_ROW_BOTTOM_Y (row
) <= last_y
)
14503 || (MATRIX_ROW_START_CHARPOS (row
) == PT
14504 && MATRIX_ROW_BOTTOM_Y (row
) < last_y
));
14505 /* If we didn't find any candidate rows, or exited the
14506 loop before all the candidates were examined, signal
14507 to the caller that this method failed. */
14508 if (rc
!= CURSOR_MOVEMENT_SUCCESS
14509 && (!rv
|| MATRIX_ROW_CONTINUATION_LINE_P (row
)))
14510 rc
= CURSOR_MOVEMENT_MUST_SCROLL
;
14512 rc
= CURSOR_MOVEMENT_SUCCESS
;
14518 if (set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0))
14520 rc
= CURSOR_MOVEMENT_SUCCESS
;
14525 while (MATRIX_ROW_BOTTOM_Y (row
) < last_y
14526 && MATRIX_ROW_START_CHARPOS (row
) == PT
14527 && cursor_row_p (row
));
14535 #if !defined USE_TOOLKIT_SCROLL_BARS || defined USE_GTK
14539 set_vertical_scroll_bar (struct window
*w
)
14541 EMACS_INT start
, end
, whole
;
14543 /* Calculate the start and end positions for the current window.
14544 At some point, it would be nice to choose between scrollbars
14545 which reflect the whole buffer size, with special markers
14546 indicating narrowing, and scrollbars which reflect only the
14549 Note that mini-buffers sometimes aren't displaying any text. */
14550 if (!MINI_WINDOW_P (w
)
14551 || (w
== XWINDOW (minibuf_window
)
14552 && NILP (echo_area_buffer
[0])))
14554 struct buffer
*buf
= XBUFFER (w
->buffer
);
14555 whole
= BUF_ZV (buf
) - BUF_BEGV (buf
);
14556 start
= marker_position (w
->start
) - BUF_BEGV (buf
);
14557 /* I don't think this is guaranteed to be right. For the
14558 moment, we'll pretend it is. */
14559 end
= BUF_Z (buf
) - XFASTINT (w
->window_end_pos
) - BUF_BEGV (buf
);
14563 if (whole
< (end
- start
))
14564 whole
= end
- start
;
14567 start
= end
= whole
= 0;
14569 /* Indicate what this scroll bar ought to be displaying now. */
14570 if (FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
14571 (*FRAME_TERMINAL (XFRAME (w
->frame
))->set_vertical_scroll_bar_hook
)
14572 (w
, end
- start
, whole
, start
);
14576 /* Redisplay leaf window WINDOW. JUST_THIS_ONE_P non-zero means only
14577 selected_window is redisplayed.
14579 We can return without actually redisplaying the window if
14580 fonts_changed_p is nonzero. In that case, redisplay_internal will
14584 redisplay_window (Lisp_Object window
, int just_this_one_p
)
14586 struct window
*w
= XWINDOW (window
);
14587 struct frame
*f
= XFRAME (w
->frame
);
14588 struct buffer
*buffer
= XBUFFER (w
->buffer
);
14589 struct buffer
*old
= current_buffer
;
14590 struct text_pos lpoint
, opoint
, startp
;
14591 int update_mode_line
;
14594 /* Record it now because it's overwritten. */
14595 int current_matrix_up_to_date_p
= 0;
14596 int used_current_matrix_p
= 0;
14597 /* This is less strict than current_matrix_up_to_date_p.
14598 It indictes that the buffer contents and narrowing are unchanged. */
14599 int buffer_unchanged_p
= 0;
14600 int temp_scroll_step
= 0;
14601 int count
= SPECPDL_INDEX ();
14603 int centering_position
= -1;
14604 int last_line_misfit
= 0;
14605 EMACS_INT beg_unchanged
, end_unchanged
;
14607 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
14610 /* W must be a leaf window here. */
14611 xassert (!NILP (w
->buffer
));
14613 *w
->desired_matrix
->method
= 0;
14617 reconsider_clip_changes (w
, buffer
);
14619 /* Has the mode line to be updated? */
14620 update_mode_line
= (!NILP (w
->update_mode_line
)
14621 || update_mode_lines
14622 || buffer
->clip_changed
14623 || buffer
->prevent_redisplay_optimizations_p
);
14625 if (MINI_WINDOW_P (w
))
14627 if (w
== XWINDOW (echo_area_window
)
14628 && !NILP (echo_area_buffer
[0]))
14630 if (update_mode_line
)
14631 /* We may have to update a tty frame's menu bar or a
14632 tool-bar. Example `M-x C-h C-h C-g'. */
14633 goto finish_menu_bars
;
14635 /* We've already displayed the echo area glyphs in this window. */
14636 goto finish_scroll_bars
;
14638 else if ((w
!= XWINDOW (minibuf_window
)
14639 || minibuf_level
== 0)
14640 /* When buffer is nonempty, redisplay window normally. */
14641 && BUF_Z (XBUFFER (w
->buffer
)) == BUF_BEG (XBUFFER (w
->buffer
))
14642 /* Quail displays non-mini buffers in minibuffer window.
14643 In that case, redisplay the window normally. */
14644 && !NILP (Fmemq (w
->buffer
, Vminibuffer_list
)))
14646 /* W is a mini-buffer window, but it's not active, so clear
14648 int yb
= window_text_bottom_y (w
);
14649 struct glyph_row
*row
;
14652 for (y
= 0, row
= w
->desired_matrix
->rows
;
14654 y
+= row
->height
, ++row
)
14655 blank_row (w
, row
, y
);
14656 goto finish_scroll_bars
;
14659 clear_glyph_matrix (w
->desired_matrix
);
14662 /* Otherwise set up data on this window; select its buffer and point
14664 /* Really select the buffer, for the sake of buffer-local
14666 set_buffer_internal_1 (XBUFFER (w
->buffer
));
14668 current_matrix_up_to_date_p
14669 = (!NILP (w
->window_end_valid
)
14670 && !current_buffer
->clip_changed
14671 && !current_buffer
->prevent_redisplay_optimizations_p
14672 && XFASTINT (w
->last_modified
) >= MODIFF
14673 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
14675 /* Run the window-bottom-change-functions
14676 if it is possible that the text on the screen has changed
14677 (either due to modification of the text, or any other reason). */
14678 if (!current_matrix_up_to_date_p
14679 && !NILP (Vwindow_text_change_functions
))
14681 safe_run_hooks (Qwindow_text_change_functions
);
14685 beg_unchanged
= BEG_UNCHANGED
;
14686 end_unchanged
= END_UNCHANGED
;
14688 SET_TEXT_POS (opoint
, PT
, PT_BYTE
);
14690 specbind (Qinhibit_point_motion_hooks
, Qt
);
14693 = (!NILP (w
->window_end_valid
)
14694 && !current_buffer
->clip_changed
14695 && XFASTINT (w
->last_modified
) >= MODIFF
14696 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
);
14698 /* When windows_or_buffers_changed is non-zero, we can't rely on
14699 the window end being valid, so set it to nil there. */
14700 if (windows_or_buffers_changed
)
14702 /* If window starts on a continuation line, maybe adjust the
14703 window start in case the window's width changed. */
14704 if (XMARKER (w
->start
)->buffer
== current_buffer
)
14705 compute_window_start_on_continuation_line (w
);
14707 w
->window_end_valid
= Qnil
;
14710 /* Some sanity checks. */
14711 CHECK_WINDOW_END (w
);
14712 if (Z
== Z_BYTE
&& CHARPOS (opoint
) != BYTEPOS (opoint
))
14714 if (BYTEPOS (opoint
) < CHARPOS (opoint
))
14717 /* If %c is in mode line, update it if needed. */
14718 if (!NILP (w
->column_number_displayed
)
14719 /* This alternative quickly identifies a common case
14720 where no change is needed. */
14721 && !(PT
== XFASTINT (w
->last_point
)
14722 && XFASTINT (w
->last_modified
) >= MODIFF
14723 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)
14724 && (XFASTINT (w
->column_number_displayed
) != current_column ()))
14725 update_mode_line
= 1;
14727 /* Count number of windows showing the selected buffer. An indirect
14728 buffer counts as its base buffer. */
14729 if (!just_this_one_p
)
14731 struct buffer
*current_base
, *window_base
;
14732 current_base
= current_buffer
;
14733 window_base
= XBUFFER (XWINDOW (selected_window
)->buffer
);
14734 if (current_base
->base_buffer
)
14735 current_base
= current_base
->base_buffer
;
14736 if (window_base
->base_buffer
)
14737 window_base
= window_base
->base_buffer
;
14738 if (current_base
== window_base
)
14742 /* Point refers normally to the selected window. For any other
14743 window, set up appropriate value. */
14744 if (!EQ (window
, selected_window
))
14746 EMACS_INT new_pt
= XMARKER (w
->pointm
)->charpos
;
14747 EMACS_INT new_pt_byte
= marker_byte_position (w
->pointm
);
14751 new_pt_byte
= BEGV_BYTE
;
14752 set_marker_both (w
->pointm
, Qnil
, BEGV
, BEGV_BYTE
);
14754 else if (new_pt
> (ZV
- 1))
14757 new_pt_byte
= ZV_BYTE
;
14758 set_marker_both (w
->pointm
, Qnil
, ZV
, ZV_BYTE
);
14761 /* We don't use SET_PT so that the point-motion hooks don't run. */
14762 TEMP_SET_PT_BOTH (new_pt
, new_pt_byte
);
14765 /* If any of the character widths specified in the display table
14766 have changed, invalidate the width run cache. It's true that
14767 this may be a bit late to catch such changes, but the rest of
14768 redisplay goes (non-fatally) haywire when the display table is
14769 changed, so why should we worry about doing any better? */
14770 if (current_buffer
->width_run_cache
)
14772 struct Lisp_Char_Table
*disptab
= buffer_display_table ();
14774 if (! disptab_matches_widthtab (disptab
,
14775 XVECTOR (BVAR (current_buffer
, width_table
))))
14777 invalidate_region_cache (current_buffer
,
14778 current_buffer
->width_run_cache
,
14780 recompute_width_table (current_buffer
, disptab
);
14784 /* If window-start is screwed up, choose a new one. */
14785 if (XMARKER (w
->start
)->buffer
!= current_buffer
)
14788 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14790 /* If someone specified a new starting point but did not insist,
14791 check whether it can be used. */
14792 if (!NILP (w
->optional_new_start
)
14793 && CHARPOS (startp
) >= BEGV
14794 && CHARPOS (startp
) <= ZV
)
14796 w
->optional_new_start
= Qnil
;
14797 start_display (&it
, w
, startp
);
14798 move_it_to (&it
, PT
, 0, it
.last_visible_y
, -1,
14799 MOVE_TO_POS
| MOVE_TO_X
| MOVE_TO_Y
);
14800 if (IT_CHARPOS (it
) == PT
)
14801 w
->force_start
= Qt
;
14802 /* IT may overshoot PT if text at PT is invisible. */
14803 else if (IT_CHARPOS (it
) > PT
&& CHARPOS (startp
) <= PT
)
14804 w
->force_start
= Qt
;
14809 /* Handle case where place to start displaying has been specified,
14810 unless the specified location is outside the accessible range. */
14811 if (!NILP (w
->force_start
)
14812 || w
->frozen_window_start_p
)
14814 /* We set this later on if we have to adjust point. */
14817 w
->force_start
= Qnil
;
14819 w
->window_end_valid
= Qnil
;
14821 /* Forget any recorded base line for line number display. */
14822 if (!buffer_unchanged_p
)
14823 w
->base_line_number
= Qnil
;
14825 /* Redisplay the mode line. Select the buffer properly for that.
14826 Also, run the hook window-scroll-functions
14827 because we have scrolled. */
14828 /* Note, we do this after clearing force_start because
14829 if there's an error, it is better to forget about force_start
14830 than to get into an infinite loop calling the hook functions
14831 and having them get more errors. */
14832 if (!update_mode_line
14833 || ! NILP (Vwindow_scroll_functions
))
14835 update_mode_line
= 1;
14836 w
->update_mode_line
= Qt
;
14837 startp
= run_window_scroll_functions (window
, startp
);
14840 w
->last_modified
= make_number (0);
14841 w
->last_overlay_modified
= make_number (0);
14842 if (CHARPOS (startp
) < BEGV
)
14843 SET_TEXT_POS (startp
, BEGV
, BEGV_BYTE
);
14844 else if (CHARPOS (startp
) > ZV
)
14845 SET_TEXT_POS (startp
, ZV
, ZV_BYTE
);
14847 /* Redisplay, then check if cursor has been set during the
14848 redisplay. Give up if new fonts were loaded. */
14849 /* We used to issue a CHECK_MARGINS argument to try_window here,
14850 but this causes scrolling to fail when point begins inside
14851 the scroll margin (bug#148) -- cyd */
14852 if (!try_window (window
, startp
, 0))
14854 w
->force_start
= Qt
;
14855 clear_glyph_matrix (w
->desired_matrix
);
14856 goto need_larger_matrices
;
14859 if (w
->cursor
.vpos
< 0 && !w
->frozen_window_start_p
)
14861 /* If point does not appear, try to move point so it does
14862 appear. The desired matrix has been built above, so we
14863 can use it here. */
14864 new_vpos
= window_box_height (w
) / 2;
14867 if (!cursor_row_fully_visible_p (w
, 0, 0))
14869 /* Point does appear, but on a line partly visible at end of window.
14870 Move it back to a fully-visible line. */
14871 new_vpos
= window_box_height (w
);
14874 /* If we need to move point for either of the above reasons,
14875 now actually do it. */
14878 struct glyph_row
*row
;
14880 row
= MATRIX_FIRST_TEXT_ROW (w
->desired_matrix
);
14881 while (MATRIX_ROW_BOTTOM_Y (row
) < new_vpos
)
14884 TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row
),
14885 MATRIX_ROW_START_BYTEPOS (row
));
14887 if (w
!= XWINDOW (selected_window
))
14888 set_marker_both (w
->pointm
, Qnil
, PT
, PT_BYTE
);
14889 else if (current_buffer
== old
)
14890 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
14892 set_cursor_from_row (w
, row
, w
->desired_matrix
, 0, 0, 0, 0);
14894 /* If we are highlighting the region, then we just changed
14895 the region, so redisplay to show it. */
14896 if (!NILP (Vtransient_mark_mode
)
14897 && !NILP (BVAR (current_buffer
, mark_active
)))
14899 clear_glyph_matrix (w
->desired_matrix
);
14900 if (!try_window (window
, startp
, 0))
14901 goto need_larger_matrices
;
14906 debug_method_add (w
, "forced window start");
14911 /* Handle case where text has not changed, only point, and it has
14912 not moved off the frame, and we are not retrying after hscroll.
14913 (current_matrix_up_to_date_p is nonzero when retrying.) */
14914 if (current_matrix_up_to_date_p
14915 && (rc
= try_cursor_movement (window
, startp
, &temp_scroll_step
),
14916 rc
!= CURSOR_MOVEMENT_CANNOT_BE_USED
))
14920 case CURSOR_MOVEMENT_SUCCESS
:
14921 used_current_matrix_p
= 1;
14924 case CURSOR_MOVEMENT_MUST_SCROLL
:
14925 goto try_to_scroll
;
14931 /* If current starting point was originally the beginning of a line
14932 but no longer is, find a new starting point. */
14933 else if (!NILP (w
->start_at_line_beg
)
14934 && !(CHARPOS (startp
) <= BEGV
14935 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n'))
14938 debug_method_add (w
, "recenter 1");
14943 /* Try scrolling with try_window_id. Value is > 0 if update has
14944 been done, it is -1 if we know that the same window start will
14945 not work. It is 0 if unsuccessful for some other reason. */
14946 else if ((tem
= try_window_id (w
)) != 0)
14949 debug_method_add (w
, "try_window_id %d", tem
);
14952 if (fonts_changed_p
)
14953 goto need_larger_matrices
;
14957 /* Otherwise try_window_id has returned -1 which means that we
14958 don't want the alternative below this comment to execute. */
14960 else if (CHARPOS (startp
) >= BEGV
14961 && CHARPOS (startp
) <= ZV
14962 && PT
>= CHARPOS (startp
)
14963 && (CHARPOS (startp
) < ZV
14964 /* Avoid starting at end of buffer. */
14965 || CHARPOS (startp
) == BEGV
14966 || (XFASTINT (w
->last_modified
) >= MODIFF
14967 && XFASTINT (w
->last_overlay_modified
) >= OVERLAY_MODIFF
)))
14970 /* If first window line is a continuation line, and window start
14971 is inside the modified region, but the first change is before
14972 current window start, we must select a new window start.
14974 However, if this is the result of a down-mouse event (e.g. by
14975 extending the mouse-drag-overlay), we don't want to select a
14976 new window start, since that would change the position under
14977 the mouse, resulting in an unwanted mouse-movement rather
14978 than a simple mouse-click. */
14979 if (NILP (w
->start_at_line_beg
)
14980 && NILP (do_mouse_tracking
)
14981 && CHARPOS (startp
) > BEGV
14982 && CHARPOS (startp
) > BEG
+ beg_unchanged
14983 && CHARPOS (startp
) <= Z
- end_unchanged
14984 /* Even if w->start_at_line_beg is nil, a new window may
14985 start at a line_beg, since that's how set_buffer_window
14986 sets it. So, we need to check the return value of
14987 compute_window_start_on_continuation_line. (See also
14989 && XMARKER (w
->start
)->buffer
== current_buffer
14990 && compute_window_start_on_continuation_line (w
))
14992 w
->force_start
= Qt
;
14993 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
14998 debug_method_add (w
, "same window start");
15001 /* Try to redisplay starting at same place as before.
15002 If point has not moved off frame, accept the results. */
15003 if (!current_matrix_up_to_date_p
15004 /* Don't use try_window_reusing_current_matrix in this case
15005 because a window scroll function can have changed the
15007 || !NILP (Vwindow_scroll_functions
)
15008 || MINI_WINDOW_P (w
)
15009 || !(used_current_matrix_p
15010 = try_window_reusing_current_matrix (w
)))
15012 IF_DEBUG (debug_method_add (w
, "1"));
15013 if (try_window (window
, startp
, TRY_WINDOW_CHECK_MARGINS
) < 0)
15014 /* -1 means we need to scroll.
15015 0 means we need new matrices, but fonts_changed_p
15016 is set in that case, so we will detect it below. */
15017 goto try_to_scroll
;
15020 if (fonts_changed_p
)
15021 goto need_larger_matrices
;
15023 if (w
->cursor
.vpos
>= 0)
15025 if (!just_this_one_p
15026 || current_buffer
->clip_changed
15027 || BEG_UNCHANGED
< CHARPOS (startp
))
15028 /* Forget any recorded base line for line number display. */
15029 w
->base_line_number
= Qnil
;
15031 if (!cursor_row_fully_visible_p (w
, 1, 0))
15033 clear_glyph_matrix (w
->desired_matrix
);
15034 last_line_misfit
= 1;
15036 /* Drop through and scroll. */
15041 clear_glyph_matrix (w
->desired_matrix
);
15046 w
->last_modified
= make_number (0);
15047 w
->last_overlay_modified
= make_number (0);
15049 /* Redisplay the mode line. Select the buffer properly for that. */
15050 if (!update_mode_line
)
15052 update_mode_line
= 1;
15053 w
->update_mode_line
= Qt
;
15056 /* Try to scroll by specified few lines. */
15057 if ((scroll_conservatively
15058 || emacs_scroll_step
15059 || temp_scroll_step
15060 || NUMBERP (BVAR (current_buffer
, scroll_up_aggressively
))
15061 || NUMBERP (BVAR (current_buffer
, scroll_down_aggressively
)))
15062 && CHARPOS (startp
) >= BEGV
15063 && CHARPOS (startp
) <= ZV
)
15065 /* The function returns -1 if new fonts were loaded, 1 if
15066 successful, 0 if not successful. */
15067 int ss
= try_scrolling (window
, just_this_one_p
,
15068 scroll_conservatively
,
15070 temp_scroll_step
, last_line_misfit
);
15073 case SCROLLING_SUCCESS
:
15076 case SCROLLING_NEED_LARGER_MATRICES
:
15077 goto need_larger_matrices
;
15079 case SCROLLING_FAILED
:
15087 /* Finally, just choose a place to start which positions point
15088 according to user preferences. */
15093 debug_method_add (w
, "recenter");
15096 /* w->vscroll = 0; */
15098 /* Forget any previously recorded base line for line number display. */
15099 if (!buffer_unchanged_p
)
15100 w
->base_line_number
= Qnil
;
15102 /* Determine the window start relative to point. */
15103 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
15104 it
.current_y
= it
.last_visible_y
;
15105 if (centering_position
< 0)
15109 ? min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4)
15111 EMACS_INT margin_pos
= CHARPOS (startp
);
15113 Lisp_Object aggressive
;
15115 /* If there is a scroll margin at the top of the window, find
15116 its character position. */
15118 /* Cannot call start_display if startp is not in the
15119 accessible region of the buffer. This can happen when we
15120 have just switched to a different buffer and/or changed
15121 its restriction. In that case, startp is initialized to
15122 the character position 1 (BEG) because we did not yet
15123 have chance to display the buffer even once. */
15124 && BEGV
<= CHARPOS (startp
) && CHARPOS (startp
) <= ZV
)
15127 void *it1data
= NULL
;
15129 SAVE_IT (it1
, it
, it1data
);
15130 start_display (&it1
, w
, startp
);
15131 move_it_vertically (&it1
, margin
);
15132 margin_pos
= IT_CHARPOS (it1
);
15133 RESTORE_IT (&it
, &it
, it1data
);
15135 scrolling_up
= PT
> margin_pos
;
15138 ? BVAR (current_buffer
, scroll_up_aggressively
)
15139 : BVAR (current_buffer
, scroll_down_aggressively
);
15141 if (!MINI_WINDOW_P (w
)
15142 && (scroll_conservatively
> SCROLL_LIMIT
|| NUMBERP (aggressive
)))
15146 /* Setting scroll-conservatively overrides
15147 scroll-*-aggressively. */
15148 if (!scroll_conservatively
&& NUMBERP (aggressive
))
15150 double float_amount
= XFLOATINT (aggressive
);
15152 pt_offset
= float_amount
* WINDOW_BOX_TEXT_HEIGHT (w
);
15153 if (pt_offset
== 0 && float_amount
> 0)
15158 /* Compute how much to move the window start backward from
15159 point so that point will be displayed where the user
15163 centering_position
= it
.last_visible_y
;
15165 centering_position
-= pt_offset
;
15166 centering_position
-=
15167 FRAME_LINE_HEIGHT (f
) * (1 + margin
+ (last_line_misfit
!= 0));
15168 /* Don't let point enter the scroll margin near top of
15170 if (centering_position
< margin
* FRAME_LINE_HEIGHT (f
))
15171 centering_position
= margin
* FRAME_LINE_HEIGHT (f
);
15174 centering_position
= margin
* FRAME_LINE_HEIGHT (f
) + pt_offset
;
15177 /* Set the window start half the height of the window backward
15179 centering_position
= window_box_height (w
) / 2;
15181 move_it_vertically_backward (&it
, centering_position
);
15183 xassert (IT_CHARPOS (it
) >= BEGV
);
15185 /* The function move_it_vertically_backward may move over more
15186 than the specified y-distance. If it->w is small, e.g. a
15187 mini-buffer window, we may end up in front of the window's
15188 display area. Start displaying at the start of the line
15189 containing PT in this case. */
15190 if (it
.current_y
<= 0)
15192 init_iterator (&it
, w
, PT
, PT_BYTE
, NULL
, DEFAULT_FACE_ID
);
15193 move_it_vertically_backward (&it
, 0);
15197 it
.current_x
= it
.hpos
= 0;
15199 /* Set the window start position here explicitly, to avoid an
15200 infinite loop in case the functions in window-scroll-functions
15202 set_marker_both (w
->start
, Qnil
, IT_CHARPOS (it
), IT_BYTEPOS (it
));
15204 /* Run scroll hooks. */
15205 startp
= run_window_scroll_functions (window
, it
.current
.pos
);
15207 /* Redisplay the window. */
15208 if (!current_matrix_up_to_date_p
15209 || windows_or_buffers_changed
15210 || cursor_type_changed
15211 /* Don't use try_window_reusing_current_matrix in this case
15212 because it can have changed the buffer. */
15213 || !NILP (Vwindow_scroll_functions
)
15214 || !just_this_one_p
15215 || MINI_WINDOW_P (w
)
15216 || !(used_current_matrix_p
15217 = try_window_reusing_current_matrix (w
)))
15218 try_window (window
, startp
, 0);
15220 /* If new fonts have been loaded (due to fontsets), give up. We
15221 have to start a new redisplay since we need to re-adjust glyph
15223 if (fonts_changed_p
)
15224 goto need_larger_matrices
;
15226 /* If cursor did not appear assume that the middle of the window is
15227 in the first line of the window. Do it again with the next line.
15228 (Imagine a window of height 100, displaying two lines of height
15229 60. Moving back 50 from it->last_visible_y will end in the first
15231 if (w
->cursor
.vpos
< 0)
15233 if (!NILP (w
->window_end_valid
)
15234 && PT
>= Z
- XFASTINT (w
->window_end_pos
))
15236 clear_glyph_matrix (w
->desired_matrix
);
15237 move_it_by_lines (&it
, 1);
15238 try_window (window
, it
.current
.pos
, 0);
15240 else if (PT
< IT_CHARPOS (it
))
15242 clear_glyph_matrix (w
->desired_matrix
);
15243 move_it_by_lines (&it
, -1);
15244 try_window (window
, it
.current
.pos
, 0);
15248 /* Not much we can do about it. */
15252 /* Consider the following case: Window starts at BEGV, there is
15253 invisible, intangible text at BEGV, so that display starts at
15254 some point START > BEGV. It can happen that we are called with
15255 PT somewhere between BEGV and START. Try to handle that case. */
15256 if (w
->cursor
.vpos
< 0)
15258 struct glyph_row
*row
= w
->current_matrix
->rows
;
15259 if (row
->mode_line_p
)
15261 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
15264 if (!cursor_row_fully_visible_p (w
, 0, 0))
15266 /* If vscroll is enabled, disable it and try again. */
15270 clear_glyph_matrix (w
->desired_matrix
);
15274 /* If centering point failed to make the whole line visible,
15275 put point at the top instead. That has to make the whole line
15276 visible, if it can be done. */
15277 if (centering_position
== 0)
15280 clear_glyph_matrix (w
->desired_matrix
);
15281 centering_position
= 0;
15287 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
15288 w
->start_at_line_beg
= ((CHARPOS (startp
) == BEGV
15289 || FETCH_BYTE (BYTEPOS (startp
) - 1) == '\n')
15292 /* Display the mode line, if we must. */
15293 if ((update_mode_line
15294 /* If window not full width, must redo its mode line
15295 if (a) the window to its side is being redone and
15296 (b) we do a frame-based redisplay. This is a consequence
15297 of how inverted lines are drawn in frame-based redisplay. */
15298 || (!just_this_one_p
15299 && !FRAME_WINDOW_P (f
)
15300 && !WINDOW_FULL_WIDTH_P (w
))
15301 /* Line number to display. */
15302 || INTEGERP (w
->base_line_pos
)
15303 /* Column number is displayed and different from the one displayed. */
15304 || (!NILP (w
->column_number_displayed
)
15305 && (XFASTINT (w
->column_number_displayed
) != current_column ())))
15306 /* This means that the window has a mode line. */
15307 && (WINDOW_WANTS_MODELINE_P (w
)
15308 || WINDOW_WANTS_HEADER_LINE_P (w
)))
15310 display_mode_lines (w
);
15312 /* If mode line height has changed, arrange for a thorough
15313 immediate redisplay using the correct mode line height. */
15314 if (WINDOW_WANTS_MODELINE_P (w
)
15315 && CURRENT_MODE_LINE_HEIGHT (w
) != DESIRED_MODE_LINE_HEIGHT (w
))
15317 fonts_changed_p
= 1;
15318 MATRIX_MODE_LINE_ROW (w
->current_matrix
)->height
15319 = DESIRED_MODE_LINE_HEIGHT (w
);
15322 /* If header line height has changed, arrange for a thorough
15323 immediate redisplay using the correct header line height. */
15324 if (WINDOW_WANTS_HEADER_LINE_P (w
)
15325 && CURRENT_HEADER_LINE_HEIGHT (w
) != DESIRED_HEADER_LINE_HEIGHT (w
))
15327 fonts_changed_p
= 1;
15328 MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->height
15329 = DESIRED_HEADER_LINE_HEIGHT (w
);
15332 if (fonts_changed_p
)
15333 goto need_larger_matrices
;
15336 if (!line_number_displayed
15337 && !BUFFERP (w
->base_line_pos
))
15339 w
->base_line_pos
= Qnil
;
15340 w
->base_line_number
= Qnil
;
15345 /* When we reach a frame's selected window, redo the frame's menu bar. */
15346 if (update_mode_line
15347 && EQ (FRAME_SELECTED_WINDOW (f
), window
))
15349 int redisplay_menu_p
= 0;
15351 if (FRAME_WINDOW_P (f
))
15353 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
15354 || defined (HAVE_NS) || defined (USE_GTK)
15355 redisplay_menu_p
= FRAME_EXTERNAL_MENU_BAR (f
);
15357 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
15361 redisplay_menu_p
= FRAME_MENU_BAR_LINES (f
) > 0;
15363 if (redisplay_menu_p
)
15364 display_menu_bar (w
);
15366 #ifdef HAVE_WINDOW_SYSTEM
15367 if (FRAME_WINDOW_P (f
))
15369 #if defined (USE_GTK) || defined (HAVE_NS)
15370 if (FRAME_EXTERNAL_TOOL_BAR (f
))
15371 redisplay_tool_bar (f
);
15373 if (WINDOWP (f
->tool_bar_window
)
15374 && (FRAME_TOOL_BAR_LINES (f
) > 0
15375 || !NILP (Vauto_resize_tool_bars
))
15376 && redisplay_tool_bar (f
))
15377 ignore_mouse_drag_p
= 1;
15383 #ifdef HAVE_WINDOW_SYSTEM
15384 if (FRAME_WINDOW_P (f
)
15385 && update_window_fringes (w
, (just_this_one_p
15386 || (!used_current_matrix_p
&& !overlay_arrow_seen
)
15387 || w
->pseudo_window_p
)))
15391 if (draw_window_fringes (w
, 1))
15392 x_draw_vertical_border (w
);
15396 #endif /* HAVE_WINDOW_SYSTEM */
15398 /* We go to this label, with fonts_changed_p nonzero,
15399 if it is necessary to try again using larger glyph matrices.
15400 We have to redeem the scroll bar even in this case,
15401 because the loop in redisplay_internal expects that. */
15402 need_larger_matrices
:
15404 finish_scroll_bars
:
15406 if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
15408 /* Set the thumb's position and size. */
15409 set_vertical_scroll_bar (w
);
15411 /* Note that we actually used the scroll bar attached to this
15412 window, so it shouldn't be deleted at the end of redisplay. */
15413 if (FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
)
15414 (*FRAME_TERMINAL (f
)->redeem_scroll_bar_hook
) (w
);
15417 /* Restore current_buffer and value of point in it. The window
15418 update may have changed the buffer, so first make sure `opoint'
15419 is still valid (Bug#6177). */
15420 if (CHARPOS (opoint
) < BEGV
)
15421 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
15422 else if (CHARPOS (opoint
) > ZV
)
15423 TEMP_SET_PT_BOTH (Z
, Z_BYTE
);
15425 TEMP_SET_PT_BOTH (CHARPOS (opoint
), BYTEPOS (opoint
));
15427 set_buffer_internal_1 (old
);
15428 /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
15429 shorter. This can be caused by log truncation in *Messages*. */
15430 if (CHARPOS (lpoint
) <= ZV
)
15431 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
15433 unbind_to (count
, Qnil
);
15437 /* Build the complete desired matrix of WINDOW with a window start
15438 buffer position POS.
15440 Value is 1 if successful. It is zero if fonts were loaded during
15441 redisplay which makes re-adjusting glyph matrices necessary, and -1
15442 if point would appear in the scroll margins.
15443 (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
15444 unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
15448 try_window (Lisp_Object window
, struct text_pos pos
, int flags
)
15450 struct window
*w
= XWINDOW (window
);
15452 struct glyph_row
*last_text_row
= NULL
;
15453 struct frame
*f
= XFRAME (w
->frame
);
15455 /* Make POS the new window start. */
15456 set_marker_both (w
->start
, Qnil
, CHARPOS (pos
), BYTEPOS (pos
));
15458 /* Mark cursor position as unknown. No overlay arrow seen. */
15459 w
->cursor
.vpos
= -1;
15460 overlay_arrow_seen
= 0;
15462 /* Initialize iterator and info to start at POS. */
15463 start_display (&it
, w
, pos
);
15465 /* Display all lines of W. */
15466 while (it
.current_y
< it
.last_visible_y
)
15468 if (display_line (&it
))
15469 last_text_row
= it
.glyph_row
- 1;
15470 if (fonts_changed_p
&& !(flags
& TRY_WINDOW_IGNORE_FONTS_CHANGE
))
15474 /* Don't let the cursor end in the scroll margins. */
15475 if ((flags
& TRY_WINDOW_CHECK_MARGINS
)
15476 && !MINI_WINDOW_P (w
))
15478 int this_scroll_margin
;
15480 if (scroll_margin
> 0)
15482 this_scroll_margin
= min (scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
15483 this_scroll_margin
*= FRAME_LINE_HEIGHT (f
);
15486 this_scroll_margin
= 0;
15488 if ((w
->cursor
.y
>= 0 /* not vscrolled */
15489 && w
->cursor
.y
< this_scroll_margin
15490 && CHARPOS (pos
) > BEGV
15491 && IT_CHARPOS (it
) < ZV
)
15492 /* rms: considering make_cursor_line_fully_visible_p here
15493 seems to give wrong results. We don't want to recenter
15494 when the last line is partly visible, we want to allow
15495 that case to be handled in the usual way. */
15496 || w
->cursor
.y
> it
.last_visible_y
- this_scroll_margin
- 1)
15498 w
->cursor
.vpos
= -1;
15499 clear_glyph_matrix (w
->desired_matrix
);
15504 /* If bottom moved off end of frame, change mode line percentage. */
15505 if (XFASTINT (w
->window_end_pos
) <= 0
15506 && Z
!= IT_CHARPOS (it
))
15507 w
->update_mode_line
= Qt
;
15509 /* Set window_end_pos to the offset of the last character displayed
15510 on the window from the end of current_buffer. Set
15511 window_end_vpos to its row number. */
15514 xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row
));
15515 w
->window_end_bytepos
15516 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
15518 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
15520 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
15521 xassert (MATRIX_ROW (w
->desired_matrix
, XFASTINT (w
->window_end_vpos
))
15522 ->displays_text_p
);
15526 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
15527 w
->window_end_pos
= make_number (Z
- ZV
);
15528 w
->window_end_vpos
= make_number (0);
15531 /* But that is not valid info until redisplay finishes. */
15532 w
->window_end_valid
= Qnil
;
15538 /************************************************************************
15539 Window redisplay reusing current matrix when buffer has not changed
15540 ************************************************************************/
15542 /* Try redisplay of window W showing an unchanged buffer with a
15543 different window start than the last time it was displayed by
15544 reusing its current matrix. Value is non-zero if successful.
15545 W->start is the new window start. */
15548 try_window_reusing_current_matrix (struct window
*w
)
15550 struct frame
*f
= XFRAME (w
->frame
);
15551 struct glyph_row
*bottom_row
;
15554 struct text_pos start
, new_start
;
15555 int nrows_scrolled
, i
;
15556 struct glyph_row
*last_text_row
;
15557 struct glyph_row
*last_reused_text_row
;
15558 struct glyph_row
*start_row
;
15559 int start_vpos
, min_y
, max_y
;
15562 if (inhibit_try_window_reusing
)
15566 if (/* This function doesn't handle terminal frames. */
15567 !FRAME_WINDOW_P (f
)
15568 /* Don't try to reuse the display if windows have been split
15570 || windows_or_buffers_changed
15571 || cursor_type_changed
)
15574 /* Can't do this if region may have changed. */
15575 if ((!NILP (Vtransient_mark_mode
)
15576 && !NILP (BVAR (current_buffer
, mark_active
)))
15577 || !NILP (w
->region_showing
)
15578 || !NILP (Vshow_trailing_whitespace
))
15581 /* If top-line visibility has changed, give up. */
15582 if (WINDOW_WANTS_HEADER_LINE_P (w
)
15583 != MATRIX_HEADER_LINE_ROW (w
->current_matrix
)->mode_line_p
)
15586 /* Give up if old or new display is scrolled vertically. We could
15587 make this function handle this, but right now it doesn't. */
15588 start_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15589 if (w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
))
15592 /* The variable new_start now holds the new window start. The old
15593 start `start' can be determined from the current matrix. */
15594 SET_TEXT_POS_FROM_MARKER (new_start
, w
->start
);
15595 start
= start_row
->minpos
;
15596 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
15598 /* Clear the desired matrix for the display below. */
15599 clear_glyph_matrix (w
->desired_matrix
);
15601 if (CHARPOS (new_start
) <= CHARPOS (start
))
15603 /* Don't use this method if the display starts with an ellipsis
15604 displayed for invisible text. It's not easy to handle that case
15605 below, and it's certainly not worth the effort since this is
15606 not a frequent case. */
15607 if (in_ellipses_for_invisible_text_p (&start_row
->start
, w
))
15610 IF_DEBUG (debug_method_add (w
, "twu1"));
15612 /* Display up to a row that can be reused. The variable
15613 last_text_row is set to the last row displayed that displays
15614 text. Note that it.vpos == 0 if or if not there is a
15615 header-line; it's not the same as the MATRIX_ROW_VPOS! */
15616 start_display (&it
, w
, new_start
);
15617 w
->cursor
.vpos
= -1;
15618 last_text_row
= last_reused_text_row
= NULL
;
15620 while (it
.current_y
< it
.last_visible_y
15621 && !fonts_changed_p
)
15623 /* If we have reached into the characters in the START row,
15624 that means the line boundaries have changed. So we
15625 can't start copying with the row START. Maybe it will
15626 work to start copying with the following row. */
15627 while (IT_CHARPOS (it
) > CHARPOS (start
))
15629 /* Advance to the next row as the "start". */
15631 start
= start_row
->minpos
;
15632 /* If there are no more rows to try, or just one, give up. */
15633 if (start_row
== MATRIX_MODE_LINE_ROW (w
->current_matrix
) - 1
15634 || w
->vscroll
|| MATRIX_ROW_PARTIALLY_VISIBLE_P (w
, start_row
)
15635 || CHARPOS (start
) == ZV
)
15637 clear_glyph_matrix (w
->desired_matrix
);
15641 start_vpos
= MATRIX_ROW_VPOS (start_row
, w
->current_matrix
);
15643 /* If we have reached alignment,
15644 we can copy the rest of the rows. */
15645 if (IT_CHARPOS (it
) == CHARPOS (start
))
15648 if (display_line (&it
))
15649 last_text_row
= it
.glyph_row
- 1;
15652 /* A value of current_y < last_visible_y means that we stopped
15653 at the previous window start, which in turn means that we
15654 have at least one reusable row. */
15655 if (it
.current_y
< it
.last_visible_y
)
15657 struct glyph_row
*row
;
15659 /* IT.vpos always starts from 0; it counts text lines. */
15660 nrows_scrolled
= it
.vpos
- (start_row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
));
15662 /* Find PT if not already found in the lines displayed. */
15663 if (w
->cursor
.vpos
< 0)
15665 int dy
= it
.current_y
- start_row
->y
;
15667 row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
15668 row
= row_containing_pos (w
, PT
, row
, NULL
, dy
);
15670 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0,
15671 dy
, nrows_scrolled
);
15674 clear_glyph_matrix (w
->desired_matrix
);
15679 /* Scroll the display. Do it before the current matrix is
15680 changed. The problem here is that update has not yet
15681 run, i.e. part of the current matrix is not up to date.
15682 scroll_run_hook will clear the cursor, and use the
15683 current matrix to get the height of the row the cursor is
15685 run
.current_y
= start_row
->y
;
15686 run
.desired_y
= it
.current_y
;
15687 run
.height
= it
.last_visible_y
- it
.current_y
;
15689 if (run
.height
> 0 && run
.current_y
!= run
.desired_y
)
15692 FRAME_RIF (f
)->update_window_begin_hook (w
);
15693 FRAME_RIF (f
)->clear_window_mouse_face (w
);
15694 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
15695 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
15699 /* Shift current matrix down by nrows_scrolled lines. */
15700 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
15701 rotate_matrix (w
->current_matrix
,
15703 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
15706 /* Disable lines that must be updated. */
15707 for (i
= 0; i
< nrows_scrolled
; ++i
)
15708 (start_row
+ i
)->enabled_p
= 0;
15710 /* Re-compute Y positions. */
15711 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
15712 max_y
= it
.last_visible_y
;
15713 for (row
= start_row
+ nrows_scrolled
;
15717 row
->y
= it
.current_y
;
15718 row
->visible_height
= row
->height
;
15720 if (row
->y
< min_y
)
15721 row
->visible_height
-= min_y
- row
->y
;
15722 if (row
->y
+ row
->height
> max_y
)
15723 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
15724 row
->redraw_fringe_bitmaps_p
= 1;
15726 it
.current_y
+= row
->height
;
15728 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
15729 last_reused_text_row
= row
;
15730 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
.last_visible_y
)
15734 /* Disable lines in the current matrix which are now
15735 below the window. */
15736 for (++row
; row
< bottom_row
; ++row
)
15737 row
->enabled_p
= row
->mode_line_p
= 0;
15740 /* Update window_end_pos etc.; last_reused_text_row is the last
15741 reused row from the current matrix containing text, if any.
15742 The value of last_text_row is the last displayed line
15743 containing text. */
15744 if (last_reused_text_row
)
15746 w
->window_end_bytepos
15747 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_reused_text_row
);
15749 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_reused_text_row
));
15751 = make_number (MATRIX_ROW_VPOS (last_reused_text_row
,
15752 w
->current_matrix
));
15754 else if (last_text_row
)
15756 w
->window_end_bytepos
15757 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
15759 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
15761 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
15765 /* This window must be completely empty. */
15766 w
->window_end_bytepos
= Z_BYTE
- ZV_BYTE
;
15767 w
->window_end_pos
= make_number (Z
- ZV
);
15768 w
->window_end_vpos
= make_number (0);
15770 w
->window_end_valid
= Qnil
;
15772 /* Update hint: don't try scrolling again in update_window. */
15773 w
->desired_matrix
->no_scrolling_p
= 1;
15776 debug_method_add (w
, "try_window_reusing_current_matrix 1");
15780 else if (CHARPOS (new_start
) > CHARPOS (start
))
15782 struct glyph_row
*pt_row
, *row
;
15783 struct glyph_row
*first_reusable_row
;
15784 struct glyph_row
*first_row_to_display
;
15786 int yb
= window_text_bottom_y (w
);
15788 /* Find the row starting at new_start, if there is one. Don't
15789 reuse a partially visible line at the end. */
15790 first_reusable_row
= start_row
;
15791 while (first_reusable_row
->enabled_p
15792 && MATRIX_ROW_BOTTOM_Y (first_reusable_row
) < yb
15793 && (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
15794 < CHARPOS (new_start
)))
15795 ++first_reusable_row
;
15797 /* Give up if there is no row to reuse. */
15798 if (MATRIX_ROW_BOTTOM_Y (first_reusable_row
) >= yb
15799 || !first_reusable_row
->enabled_p
15800 || (MATRIX_ROW_START_CHARPOS (first_reusable_row
)
15801 != CHARPOS (new_start
)))
15804 /* We can reuse fully visible rows beginning with
15805 first_reusable_row to the end of the window. Set
15806 first_row_to_display to the first row that cannot be reused.
15807 Set pt_row to the row containing point, if there is any. */
15809 for (first_row_to_display
= first_reusable_row
;
15810 MATRIX_ROW_BOTTOM_Y (first_row_to_display
) < yb
;
15811 ++first_row_to_display
)
15813 if (PT
>= MATRIX_ROW_START_CHARPOS (first_row_to_display
)
15814 && PT
< MATRIX_ROW_END_CHARPOS (first_row_to_display
))
15815 pt_row
= first_row_to_display
;
15818 /* Start displaying at the start of first_row_to_display. */
15819 xassert (first_row_to_display
->y
< yb
);
15820 init_to_row_start (&it
, w
, first_row_to_display
);
15822 nrows_scrolled
= (MATRIX_ROW_VPOS (first_reusable_row
, w
->current_matrix
)
15824 it
.vpos
= (MATRIX_ROW_VPOS (first_row_to_display
, w
->current_matrix
)
15826 it
.current_y
= (first_row_to_display
->y
- first_reusable_row
->y
15827 + WINDOW_HEADER_LINE_HEIGHT (w
));
15829 /* Display lines beginning with first_row_to_display in the
15830 desired matrix. Set last_text_row to the last row displayed
15831 that displays text. */
15832 it
.glyph_row
= MATRIX_ROW (w
->desired_matrix
, it
.vpos
);
15833 if (pt_row
== NULL
)
15834 w
->cursor
.vpos
= -1;
15835 last_text_row
= NULL
;
15836 while (it
.current_y
< it
.last_visible_y
&& !fonts_changed_p
)
15837 if (display_line (&it
))
15838 last_text_row
= it
.glyph_row
- 1;
15840 /* If point is in a reused row, adjust y and vpos of the cursor
15844 w
->cursor
.vpos
-= nrows_scrolled
;
15845 w
->cursor
.y
-= first_reusable_row
->y
- start_row
->y
;
15848 /* Give up if point isn't in a row displayed or reused. (This
15849 also handles the case where w->cursor.vpos < nrows_scrolled
15850 after the calls to display_line, which can happen with scroll
15851 margins. See bug#1295.) */
15852 if (w
->cursor
.vpos
< 0)
15854 clear_glyph_matrix (w
->desired_matrix
);
15858 /* Scroll the display. */
15859 run
.current_y
= first_reusable_row
->y
;
15860 run
.desired_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
15861 run
.height
= it
.last_visible_y
- run
.current_y
;
15862 dy
= run
.current_y
- run
.desired_y
;
15867 FRAME_RIF (f
)->update_window_begin_hook (w
);
15868 FRAME_RIF (f
)->clear_window_mouse_face (w
);
15869 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
15870 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
15874 /* Adjust Y positions of reused rows. */
15875 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
);
15876 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
15877 max_y
= it
.last_visible_y
;
15878 for (row
= first_reusable_row
; row
< first_row_to_display
; ++row
)
15881 row
->visible_height
= row
->height
;
15882 if (row
->y
< min_y
)
15883 row
->visible_height
-= min_y
- row
->y
;
15884 if (row
->y
+ row
->height
> max_y
)
15885 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
15886 row
->redraw_fringe_bitmaps_p
= 1;
15889 /* Scroll the current matrix. */
15890 xassert (nrows_scrolled
> 0);
15891 rotate_matrix (w
->current_matrix
,
15893 MATRIX_ROW_VPOS (bottom_row
, w
->current_matrix
),
15896 /* Disable rows not reused. */
15897 for (row
-= nrows_scrolled
; row
< bottom_row
; ++row
)
15898 row
->enabled_p
= 0;
15900 /* Point may have moved to a different line, so we cannot assume that
15901 the previous cursor position is valid; locate the correct row. */
15904 for (row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
15905 row
< bottom_row
&& PT
>= MATRIX_ROW_END_CHARPOS (row
);
15909 w
->cursor
.y
= row
->y
;
15911 if (row
< bottom_row
)
15913 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
15914 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
15916 /* Can't use this optimization with bidi-reordered glyph
15917 rows, unless cursor is already at point. */
15918 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
)))
15920 if (!(w
->cursor
.hpos
>= 0
15921 && w
->cursor
.hpos
< row
->used
[TEXT_AREA
]
15922 && BUFFERP (glyph
->object
)
15923 && glyph
->charpos
== PT
))
15928 && (!BUFFERP (glyph
->object
)
15929 || glyph
->charpos
< PT
);
15933 w
->cursor
.x
+= glyph
->pixel_width
;
15938 /* Adjust window end. A null value of last_text_row means that
15939 the window end is in reused rows which in turn means that
15940 only its vpos can have changed. */
15943 w
->window_end_bytepos
15944 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
15946 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
15948 = make_number (MATRIX_ROW_VPOS (last_text_row
, w
->desired_matrix
));
15953 = make_number (XFASTINT (w
->window_end_vpos
) - nrows_scrolled
);
15956 w
->window_end_valid
= Qnil
;
15957 w
->desired_matrix
->no_scrolling_p
= 1;
15960 debug_method_add (w
, "try_window_reusing_current_matrix 2");
15970 /************************************************************************
15971 Window redisplay reusing current matrix when buffer has changed
15972 ************************************************************************/
15974 static struct glyph_row
*find_last_unchanged_at_beg_row (struct window
*);
15975 static struct glyph_row
*find_first_unchanged_at_end_row (struct window
*,
15976 EMACS_INT
*, EMACS_INT
*);
15977 static struct glyph_row
*
15978 find_last_row_displaying_text (struct glyph_matrix
*, struct it
*,
15979 struct glyph_row
*);
15982 /* Return the last row in MATRIX displaying text. If row START is
15983 non-null, start searching with that row. IT gives the dimensions
15984 of the display. Value is null if matrix is empty; otherwise it is
15985 a pointer to the row found. */
15987 static struct glyph_row
*
15988 find_last_row_displaying_text (struct glyph_matrix
*matrix
, struct it
*it
,
15989 struct glyph_row
*start
)
15991 struct glyph_row
*row
, *row_found
;
15993 /* Set row_found to the last row in IT->w's current matrix
15994 displaying text. The loop looks funny but think of partially
15997 row
= start
? start
: MATRIX_FIRST_TEXT_ROW (matrix
);
15998 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16000 xassert (row
->enabled_p
);
16002 if (MATRIX_ROW_BOTTOM_Y (row
) >= it
->last_visible_y
)
16011 /* Return the last row in the current matrix of W that is not affected
16012 by changes at the start of current_buffer that occurred since W's
16013 current matrix was built. Value is null if no such row exists.
16015 BEG_UNCHANGED us the number of characters unchanged at the start of
16016 current_buffer. BEG + BEG_UNCHANGED is the buffer position of the
16017 first changed character in current_buffer. Characters at positions <
16018 BEG + BEG_UNCHANGED are at the same buffer positions as they were
16019 when the current matrix was built. */
16021 static struct glyph_row
*
16022 find_last_unchanged_at_beg_row (struct window
*w
)
16024 EMACS_INT first_changed_pos
= BEG
+ BEG_UNCHANGED
;
16025 struct glyph_row
*row
;
16026 struct glyph_row
*row_found
= NULL
;
16027 int yb
= window_text_bottom_y (w
);
16029 /* Find the last row displaying unchanged text. */
16030 for (row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16031 MATRIX_ROW_DISPLAYS_TEXT_P (row
)
16032 && MATRIX_ROW_START_CHARPOS (row
) < first_changed_pos
;
16035 if (/* If row ends before first_changed_pos, it is unchanged,
16036 except in some case. */
16037 MATRIX_ROW_END_CHARPOS (row
) <= first_changed_pos
16038 /* When row ends in ZV and we write at ZV it is not
16040 && !row
->ends_at_zv_p
16041 /* When first_changed_pos is the end of a continued line,
16042 row is not unchanged because it may be no longer
16044 && !(MATRIX_ROW_END_CHARPOS (row
) == first_changed_pos
16045 && (row
->continued_p
16046 || row
->exact_window_width_line_p
)))
16049 /* Stop if last visible row. */
16050 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
16058 /* Find the first glyph row in the current matrix of W that is not
16059 affected by changes at the end of current_buffer since the
16060 time W's current matrix was built.
16062 Return in *DELTA the number of chars by which buffer positions in
16063 unchanged text at the end of current_buffer must be adjusted.
16065 Return in *DELTA_BYTES the corresponding number of bytes.
16067 Value is null if no such row exists, i.e. all rows are affected by
16070 static struct glyph_row
*
16071 find_first_unchanged_at_end_row (struct window
*w
,
16072 EMACS_INT
*delta
, EMACS_INT
*delta_bytes
)
16074 struct glyph_row
*row
;
16075 struct glyph_row
*row_found
= NULL
;
16077 *delta
= *delta_bytes
= 0;
16079 /* Display must not have been paused, otherwise the current matrix
16080 is not up to date. */
16081 eassert (!NILP (w
->window_end_valid
));
16083 /* A value of window_end_pos >= END_UNCHANGED means that the window
16084 end is in the range of changed text. If so, there is no
16085 unchanged row at the end of W's current matrix. */
16086 if (XFASTINT (w
->window_end_pos
) >= END_UNCHANGED
)
16089 /* Set row to the last row in W's current matrix displaying text. */
16090 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
16092 /* If matrix is entirely empty, no unchanged row exists. */
16093 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16095 /* The value of row is the last glyph row in the matrix having a
16096 meaningful buffer position in it. The end position of row
16097 corresponds to window_end_pos. This allows us to translate
16098 buffer positions in the current matrix to current buffer
16099 positions for characters not in changed text. */
16101 MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
16102 EMACS_INT Z_BYTE_old
=
16103 MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
16104 EMACS_INT last_unchanged_pos
, last_unchanged_pos_old
;
16105 struct glyph_row
*first_text_row
16106 = MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
16108 *delta
= Z
- Z_old
;
16109 *delta_bytes
= Z_BYTE
- Z_BYTE_old
;
16111 /* Set last_unchanged_pos to the buffer position of the last
16112 character in the buffer that has not been changed. Z is the
16113 index + 1 of the last character in current_buffer, i.e. by
16114 subtracting END_UNCHANGED we get the index of the last
16115 unchanged character, and we have to add BEG to get its buffer
16117 last_unchanged_pos
= Z
- END_UNCHANGED
+ BEG
;
16118 last_unchanged_pos_old
= last_unchanged_pos
- *delta
;
16120 /* Search backward from ROW for a row displaying a line that
16121 starts at a minimum position >= last_unchanged_pos_old. */
16122 for (; row
> first_text_row
; --row
)
16124 /* This used to abort, but it can happen.
16125 It is ok to just stop the search instead here. KFS. */
16126 if (!row
->enabled_p
|| !MATRIX_ROW_DISPLAYS_TEXT_P (row
))
16129 if (MATRIX_ROW_START_CHARPOS (row
) >= last_unchanged_pos_old
)
16134 eassert (!row_found
|| MATRIX_ROW_DISPLAYS_TEXT_P (row_found
));
16140 /* Make sure that glyph rows in the current matrix of window W
16141 reference the same glyph memory as corresponding rows in the
16142 frame's frame matrix. This function is called after scrolling W's
16143 current matrix on a terminal frame in try_window_id and
16144 try_window_reusing_current_matrix. */
16147 sync_frame_with_window_matrix_rows (struct window
*w
)
16149 struct frame
*f
= XFRAME (w
->frame
);
16150 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
16152 /* Preconditions: W must be a leaf window and full-width. Its frame
16153 must have a frame matrix. */
16154 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
16155 xassert (WINDOW_FULL_WIDTH_P (w
));
16156 xassert (!FRAME_WINDOW_P (f
));
16158 /* If W is a full-width window, glyph pointers in W's current matrix
16159 have, by definition, to be the same as glyph pointers in the
16160 corresponding frame matrix. Note that frame matrices have no
16161 marginal areas (see build_frame_matrix). */
16162 window_row
= w
->current_matrix
->rows
;
16163 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
16164 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
16165 while (window_row
< window_row_end
)
16167 struct glyph
*start
= window_row
->glyphs
[LEFT_MARGIN_AREA
];
16168 struct glyph
*end
= window_row
->glyphs
[LAST_AREA
];
16170 frame_row
->glyphs
[LEFT_MARGIN_AREA
] = start
;
16171 frame_row
->glyphs
[TEXT_AREA
] = start
;
16172 frame_row
->glyphs
[RIGHT_MARGIN_AREA
] = end
;
16173 frame_row
->glyphs
[LAST_AREA
] = end
;
16175 /* Disable frame rows whose corresponding window rows have
16176 been disabled in try_window_id. */
16177 if (!window_row
->enabled_p
)
16178 frame_row
->enabled_p
= 0;
16180 ++window_row
, ++frame_row
;
16185 /* Find the glyph row in window W containing CHARPOS. Consider all
16186 rows between START and END (not inclusive). END null means search
16187 all rows to the end of the display area of W. Value is the row
16188 containing CHARPOS or null. */
16191 row_containing_pos (struct window
*w
, EMACS_INT charpos
,
16192 struct glyph_row
*start
, struct glyph_row
*end
, int dy
)
16194 struct glyph_row
*row
= start
;
16195 struct glyph_row
*best_row
= NULL
;
16196 EMACS_INT mindif
= BUF_ZV (XBUFFER (w
->buffer
)) + 1;
16199 /* If we happen to start on a header-line, skip that. */
16200 if (row
->mode_line_p
)
16203 if ((end
&& row
>= end
) || !row
->enabled_p
)
16206 last_y
= window_text_bottom_y (w
) - dy
;
16210 /* Give up if we have gone too far. */
16211 if (end
&& row
>= end
)
16213 /* This formerly returned if they were equal.
16214 I think that both quantities are of a "last plus one" type;
16215 if so, when they are equal, the row is within the screen. -- rms. */
16216 if (MATRIX_ROW_BOTTOM_Y (row
) > last_y
)
16219 /* If it is in this row, return this row. */
16220 if (! (MATRIX_ROW_END_CHARPOS (row
) < charpos
16221 || (MATRIX_ROW_END_CHARPOS (row
) == charpos
16222 /* The end position of a row equals the start
16223 position of the next row. If CHARPOS is there, we
16224 would rather display it in the next line, except
16225 when this line ends in ZV. */
16226 && !row
->ends_at_zv_p
16227 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
16228 && charpos
>= MATRIX_ROW_START_CHARPOS (row
))
16232 if (NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
16233 || (!best_row
&& !row
->continued_p
))
16235 /* In bidi-reordered rows, there could be several rows
16236 occluding point, all of them belonging to the same
16237 continued line. We need to find the row which fits
16238 CHARPOS the best. */
16239 for (g
= row
->glyphs
[TEXT_AREA
];
16240 g
< row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
16243 if (!STRINGP (g
->object
))
16245 if (g
->charpos
> 0 && eabs (g
->charpos
- charpos
) < mindif
)
16247 mindif
= eabs (g
->charpos
- charpos
);
16249 /* Exact match always wins. */
16256 else if (best_row
&& !row
->continued_p
)
16263 /* Try to redisplay window W by reusing its existing display. W's
16264 current matrix must be up to date when this function is called,
16265 i.e. window_end_valid must not be nil.
16269 1 if display has been updated
16270 0 if otherwise unsuccessful
16271 -1 if redisplay with same window start is known not to succeed
16273 The following steps are performed:
16275 1. Find the last row in the current matrix of W that is not
16276 affected by changes at the start of current_buffer. If no such row
16279 2. Find the first row in W's current matrix that is not affected by
16280 changes at the end of current_buffer. Maybe there is no such row.
16282 3. Display lines beginning with the row + 1 found in step 1 to the
16283 row found in step 2 or, if step 2 didn't find a row, to the end of
16286 4. If cursor is not known to appear on the window, give up.
16288 5. If display stopped at the row found in step 2, scroll the
16289 display and current matrix as needed.
16291 6. Maybe display some lines at the end of W, if we must. This can
16292 happen under various circumstances, like a partially visible line
16293 becoming fully visible, or because newly displayed lines are displayed
16294 in smaller font sizes.
16296 7. Update W's window end information. */
16299 try_window_id (struct window
*w
)
16301 struct frame
*f
= XFRAME (w
->frame
);
16302 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
16303 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
16304 struct glyph_row
*last_unchanged_at_beg_row
;
16305 struct glyph_row
*first_unchanged_at_end_row
;
16306 struct glyph_row
*row
;
16307 struct glyph_row
*bottom_row
;
16310 EMACS_INT delta
= 0, delta_bytes
= 0, stop_pos
;
16312 struct text_pos start_pos
;
16314 int first_unchanged_at_end_vpos
= 0;
16315 struct glyph_row
*last_text_row
, *last_text_row_at_end
;
16316 struct text_pos start
;
16317 EMACS_INT first_changed_charpos
, last_changed_charpos
;
16320 if (inhibit_try_window_id
)
16324 /* This is handy for debugging. */
16326 #define GIVE_UP(X) \
16328 fprintf (stderr, "try_window_id give up %d\n", (X)); \
16332 #define GIVE_UP(X) return 0
16335 SET_TEXT_POS_FROM_MARKER (start
, w
->start
);
16337 /* Don't use this for mini-windows because these can show
16338 messages and mini-buffers, and we don't handle that here. */
16339 if (MINI_WINDOW_P (w
))
16342 /* This flag is used to prevent redisplay optimizations. */
16343 if (windows_or_buffers_changed
|| cursor_type_changed
)
16346 /* Verify that narrowing has not changed.
16347 Also verify that we were not told to prevent redisplay optimizations.
16348 It would be nice to further
16349 reduce the number of cases where this prevents try_window_id. */
16350 if (current_buffer
->clip_changed
16351 || current_buffer
->prevent_redisplay_optimizations_p
)
16354 /* Window must either use window-based redisplay or be full width. */
16355 if (!FRAME_WINDOW_P (f
)
16356 && (!FRAME_LINE_INS_DEL_OK (f
)
16357 || !WINDOW_FULL_WIDTH_P (w
)))
16360 /* Give up if point is known NOT to appear in W. */
16361 if (PT
< CHARPOS (start
))
16364 /* Another way to prevent redisplay optimizations. */
16365 if (XFASTINT (w
->last_modified
) == 0)
16368 /* Verify that window is not hscrolled. */
16369 if (XFASTINT (w
->hscroll
) != 0)
16372 /* Verify that display wasn't paused. */
16373 if (NILP (w
->window_end_valid
))
16376 /* Can't use this if highlighting a region because a cursor movement
16377 will do more than just set the cursor. */
16378 if (!NILP (Vtransient_mark_mode
)
16379 && !NILP (BVAR (current_buffer
, mark_active
)))
16382 /* Likewise if highlighting trailing whitespace. */
16383 if (!NILP (Vshow_trailing_whitespace
))
16386 /* Likewise if showing a region. */
16387 if (!NILP (w
->region_showing
))
16390 /* Can't use this if overlay arrow position and/or string have
16392 if (overlay_arrows_changed_p ())
16395 /* When word-wrap is on, adding a space to the first word of a
16396 wrapped line can change the wrap position, altering the line
16397 above it. It might be worthwhile to handle this more
16398 intelligently, but for now just redisplay from scratch. */
16399 if (!NILP (BVAR (XBUFFER (w
->buffer
), word_wrap
)))
16402 /* Under bidi reordering, adding or deleting a character in the
16403 beginning of a paragraph, before the first strong directional
16404 character, can change the base direction of the paragraph (unless
16405 the buffer specifies a fixed paragraph direction), which will
16406 require to redisplay the whole paragraph. It might be worthwhile
16407 to find the paragraph limits and widen the range of redisplayed
16408 lines to that, but for now just give up this optimization and
16409 redisplay from scratch. */
16410 if (!NILP (BVAR (XBUFFER (w
->buffer
), bidi_display_reordering
))
16411 && NILP (BVAR (XBUFFER (w
->buffer
), bidi_paragraph_direction
)))
16414 /* Make sure beg_unchanged and end_unchanged are up to date. Do it
16415 only if buffer has really changed. The reason is that the gap is
16416 initially at Z for freshly visited files. The code below would
16417 set end_unchanged to 0 in that case. */
16418 if (MODIFF
> SAVE_MODIFF
16419 /* This seems to happen sometimes after saving a buffer. */
16420 || BEG_UNCHANGED
+ END_UNCHANGED
> Z_BYTE
)
16422 if (GPT
- BEG
< BEG_UNCHANGED
)
16423 BEG_UNCHANGED
= GPT
- BEG
;
16424 if (Z
- GPT
< END_UNCHANGED
)
16425 END_UNCHANGED
= Z
- GPT
;
16428 /* The position of the first and last character that has been changed. */
16429 first_changed_charpos
= BEG
+ BEG_UNCHANGED
;
16430 last_changed_charpos
= Z
- END_UNCHANGED
;
16432 /* If window starts after a line end, and the last change is in
16433 front of that newline, then changes don't affect the display.
16434 This case happens with stealth-fontification. Note that although
16435 the display is unchanged, glyph positions in the matrix have to
16436 be adjusted, of course. */
16437 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
16438 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
16439 && ((last_changed_charpos
< CHARPOS (start
)
16440 && CHARPOS (start
) == BEGV
)
16441 || (last_changed_charpos
< CHARPOS (start
) - 1
16442 && FETCH_BYTE (BYTEPOS (start
) - 1) == '\n')))
16444 EMACS_INT Z_old
, Z_delta
, Z_BYTE_old
, Z_delta_bytes
;
16445 struct glyph_row
*r0
;
16447 /* Compute how many chars/bytes have been added to or removed
16448 from the buffer. */
16449 Z_old
= MATRIX_ROW_END_CHARPOS (row
) + XFASTINT (w
->window_end_pos
);
16450 Z_BYTE_old
= MATRIX_ROW_END_BYTEPOS (row
) + w
->window_end_bytepos
;
16451 Z_delta
= Z
- Z_old
;
16452 Z_delta_bytes
= Z_BYTE
- Z_BYTE_old
;
16454 /* Give up if PT is not in the window. Note that it already has
16455 been checked at the start of try_window_id that PT is not in
16456 front of the window start. */
16457 if (PT
>= MATRIX_ROW_END_CHARPOS (row
) + Z_delta
)
16460 /* If window start is unchanged, we can reuse the whole matrix
16461 as is, after adjusting glyph positions. No need to compute
16462 the window end again, since its offset from Z hasn't changed. */
16463 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
16464 if (CHARPOS (start
) == MATRIX_ROW_START_CHARPOS (r0
) + Z_delta
16465 && BYTEPOS (start
) == MATRIX_ROW_START_BYTEPOS (r0
) + Z_delta_bytes
16466 /* PT must not be in a partially visible line. */
16467 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
) + Z_delta
16468 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
16470 /* Adjust positions in the glyph matrix. */
16471 if (Z_delta
|| Z_delta_bytes
)
16473 struct glyph_row
*r1
16474 = MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
16475 increment_matrix_positions (w
->current_matrix
,
16476 MATRIX_ROW_VPOS (r0
, current_matrix
),
16477 MATRIX_ROW_VPOS (r1
, current_matrix
),
16478 Z_delta
, Z_delta_bytes
);
16481 /* Set the cursor. */
16482 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
16484 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
16491 /* Handle the case that changes are all below what is displayed in
16492 the window, and that PT is in the window. This shortcut cannot
16493 be taken if ZV is visible in the window, and text has been added
16494 there that is visible in the window. */
16495 if (first_changed_charpos
>= MATRIX_ROW_END_CHARPOS (row
)
16496 /* ZV is not visible in the window, or there are no
16497 changes at ZV, actually. */
16498 && (current_matrix
->zv
> MATRIX_ROW_END_CHARPOS (row
)
16499 || first_changed_charpos
== last_changed_charpos
))
16501 struct glyph_row
*r0
;
16503 /* Give up if PT is not in the window. Note that it already has
16504 been checked at the start of try_window_id that PT is not in
16505 front of the window start. */
16506 if (PT
>= MATRIX_ROW_END_CHARPOS (row
))
16509 /* If window start is unchanged, we can reuse the whole matrix
16510 as is, without changing glyph positions since no text has
16511 been added/removed in front of the window end. */
16512 r0
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
16513 if (TEXT_POS_EQUAL_P (start
, r0
->minpos
)
16514 /* PT must not be in a partially visible line. */
16515 && !(PT
>= MATRIX_ROW_START_CHARPOS (row
)
16516 && MATRIX_ROW_BOTTOM_Y (row
) > window_text_bottom_y (w
)))
16518 /* We have to compute the window end anew since text
16519 could have been added/removed after it. */
16521 = make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
16522 w
->window_end_bytepos
16523 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
16525 /* Set the cursor. */
16526 row
= row_containing_pos (w
, PT
, r0
, NULL
, 0);
16528 set_cursor_from_row (w
, row
, current_matrix
, 0, 0, 0, 0);
16535 /* Give up if window start is in the changed area.
16537 The condition used to read
16539 (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
16541 but why that was tested escapes me at the moment. */
16542 if (CHARPOS (start
) >= first_changed_charpos
16543 && CHARPOS (start
) <= last_changed_charpos
)
16546 /* Check that window start agrees with the start of the first glyph
16547 row in its current matrix. Check this after we know the window
16548 start is not in changed text, otherwise positions would not be
16550 row
= MATRIX_FIRST_TEXT_ROW (current_matrix
);
16551 if (!TEXT_POS_EQUAL_P (start
, row
->minpos
))
16554 /* Give up if the window ends in strings. Overlay strings
16555 at the end are difficult to handle, so don't try. */
16556 row
= MATRIX_ROW (current_matrix
, XFASTINT (w
->window_end_vpos
));
16557 if (MATRIX_ROW_START_CHARPOS (row
) == MATRIX_ROW_END_CHARPOS (row
))
16560 /* Compute the position at which we have to start displaying new
16561 lines. Some of the lines at the top of the window might be
16562 reusable because they are not displaying changed text. Find the
16563 last row in W's current matrix not affected by changes at the
16564 start of current_buffer. Value is null if changes start in the
16565 first line of window. */
16566 last_unchanged_at_beg_row
= find_last_unchanged_at_beg_row (w
);
16567 if (last_unchanged_at_beg_row
)
16569 /* Avoid starting to display in the moddle of a character, a TAB
16570 for instance. This is easier than to set up the iterator
16571 exactly, and it's not a frequent case, so the additional
16572 effort wouldn't really pay off. */
16573 while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
)
16574 || last_unchanged_at_beg_row
->ends_in_newline_from_string_p
)
16575 && last_unchanged_at_beg_row
> w
->current_matrix
->rows
)
16576 --last_unchanged_at_beg_row
;
16578 if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row
))
16581 if (init_to_row_end (&it
, w
, last_unchanged_at_beg_row
) == 0)
16583 start_pos
= it
.current
.pos
;
16585 /* Start displaying new lines in the desired matrix at the same
16586 vpos we would use in the current matrix, i.e. below
16587 last_unchanged_at_beg_row. */
16588 it
.vpos
= 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row
,
16590 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
16591 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row
);
16593 xassert (it
.hpos
== 0 && it
.current_x
== 0);
16597 /* There are no reusable lines at the start of the window.
16598 Start displaying in the first text line. */
16599 start_display (&it
, w
, start
);
16600 it
.vpos
= it
.first_vpos
;
16601 start_pos
= it
.current
.pos
;
16604 /* Find the first row that is not affected by changes at the end of
16605 the buffer. Value will be null if there is no unchanged row, in
16606 which case we must redisplay to the end of the window. delta
16607 will be set to the value by which buffer positions beginning with
16608 first_unchanged_at_end_row have to be adjusted due to text
16610 first_unchanged_at_end_row
16611 = find_first_unchanged_at_end_row (w
, &delta
, &delta_bytes
);
16612 IF_DEBUG (debug_delta
= delta
);
16613 IF_DEBUG (debug_delta_bytes
= delta_bytes
);
16615 /* Set stop_pos to the buffer position up to which we will have to
16616 display new lines. If first_unchanged_at_end_row != NULL, this
16617 is the buffer position of the start of the line displayed in that
16618 row. For first_unchanged_at_end_row == NULL, use 0 to indicate
16619 that we don't stop at a buffer position. */
16621 if (first_unchanged_at_end_row
)
16623 xassert (last_unchanged_at_beg_row
== NULL
16624 || first_unchanged_at_end_row
>= last_unchanged_at_beg_row
);
16626 /* If this is a continuation line, move forward to the next one
16627 that isn't. Changes in lines above affect this line.
16628 Caution: this may move first_unchanged_at_end_row to a row
16629 not displaying text. */
16630 while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row
)
16631 && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
16632 && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
16633 < it
.last_visible_y
))
16634 ++first_unchanged_at_end_row
;
16636 if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
)
16637 || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row
)
16638 >= it
.last_visible_y
))
16639 first_unchanged_at_end_row
= NULL
;
16642 stop_pos
= (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row
)
16644 first_unchanged_at_end_vpos
16645 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, current_matrix
);
16646 xassert (stop_pos
>= Z
- END_UNCHANGED
);
16649 else if (last_unchanged_at_beg_row
== NULL
)
16655 /* Either there is no unchanged row at the end, or the one we have
16656 now displays text. This is a necessary condition for the window
16657 end pos calculation at the end of this function. */
16658 xassert (first_unchanged_at_end_row
== NULL
16659 || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
));
16661 debug_last_unchanged_at_beg_vpos
16662 = (last_unchanged_at_beg_row
16663 ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row
, current_matrix
)
16665 debug_first_unchanged_at_end_vpos
= first_unchanged_at_end_vpos
;
16667 #endif /* GLYPH_DEBUG != 0 */
16670 /* Display new lines. Set last_text_row to the last new line
16671 displayed which has text on it, i.e. might end up as being the
16672 line where the window_end_vpos is. */
16673 w
->cursor
.vpos
= -1;
16674 last_text_row
= NULL
;
16675 overlay_arrow_seen
= 0;
16676 while (it
.current_y
< it
.last_visible_y
16677 && !fonts_changed_p
16678 && (first_unchanged_at_end_row
== NULL
16679 || IT_CHARPOS (it
) < stop_pos
))
16681 if (display_line (&it
))
16682 last_text_row
= it
.glyph_row
- 1;
16685 if (fonts_changed_p
)
16689 /* Compute differences in buffer positions, y-positions etc. for
16690 lines reused at the bottom of the window. Compute what we can
16692 if (first_unchanged_at_end_row
16693 /* No lines reused because we displayed everything up to the
16694 bottom of the window. */
16695 && it
.current_y
< it
.last_visible_y
)
16698 - MATRIX_ROW_VPOS (first_unchanged_at_end_row
,
16700 dy
= it
.current_y
- first_unchanged_at_end_row
->y
;
16701 run
.current_y
= first_unchanged_at_end_row
->y
;
16702 run
.desired_y
= run
.current_y
+ dy
;
16703 run
.height
= it
.last_visible_y
- max (run
.current_y
, run
.desired_y
);
16707 delta
= delta_bytes
= dvpos
= dy
16708 = run
.current_y
= run
.desired_y
= run
.height
= 0;
16709 first_unchanged_at_end_row
= NULL
;
16711 IF_DEBUG (debug_dvpos
= dvpos
; debug_dy
= dy
);
16714 /* Find the cursor if not already found. We have to decide whether
16715 PT will appear on this window (it sometimes doesn't, but this is
16716 not a very frequent case.) This decision has to be made before
16717 the current matrix is altered. A value of cursor.vpos < 0 means
16718 that PT is either in one of the lines beginning at
16719 first_unchanged_at_end_row or below the window. Don't care for
16720 lines that might be displayed later at the window end; as
16721 mentioned, this is not a frequent case. */
16722 if (w
->cursor
.vpos
< 0)
16724 /* Cursor in unchanged rows at the top? */
16725 if (PT
< CHARPOS (start_pos
)
16726 && last_unchanged_at_beg_row
)
16728 row
= row_containing_pos (w
, PT
,
16729 MATRIX_FIRST_TEXT_ROW (w
->current_matrix
),
16730 last_unchanged_at_beg_row
+ 1, 0);
16732 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
16735 /* Start from first_unchanged_at_end_row looking for PT. */
16736 else if (first_unchanged_at_end_row
)
16738 row
= row_containing_pos (w
, PT
- delta
,
16739 first_unchanged_at_end_row
, NULL
, 0);
16741 set_cursor_from_row (w
, row
, w
->current_matrix
, delta
,
16742 delta_bytes
, dy
, dvpos
);
16745 /* Give up if cursor was not found. */
16746 if (w
->cursor
.vpos
< 0)
16748 clear_glyph_matrix (w
->desired_matrix
);
16753 /* Don't let the cursor end in the scroll margins. */
16755 int this_scroll_margin
, cursor_height
;
16757 this_scroll_margin
= max (0, scroll_margin
);
16758 this_scroll_margin
= min (this_scroll_margin
, WINDOW_TOTAL_LINES (w
) / 4);
16759 this_scroll_margin
*= FRAME_LINE_HEIGHT (it
.f
);
16760 cursor_height
= MATRIX_ROW (w
->desired_matrix
, w
->cursor
.vpos
)->height
;
16762 if ((w
->cursor
.y
< this_scroll_margin
16763 && CHARPOS (start
) > BEGV
)
16764 /* Old redisplay didn't take scroll margin into account at the bottom,
16765 but then global-hl-line-mode doesn't scroll. KFS 2004-06-14 */
16766 || (w
->cursor
.y
+ (make_cursor_line_fully_visible_p
16767 ? cursor_height
+ this_scroll_margin
16768 : 1)) > it
.last_visible_y
)
16770 w
->cursor
.vpos
= -1;
16771 clear_glyph_matrix (w
->desired_matrix
);
16776 /* Scroll the display. Do it before changing the current matrix so
16777 that xterm.c doesn't get confused about where the cursor glyph is
16779 if (dy
&& run
.height
)
16783 if (FRAME_WINDOW_P (f
))
16785 FRAME_RIF (f
)->update_window_begin_hook (w
);
16786 FRAME_RIF (f
)->clear_window_mouse_face (w
);
16787 FRAME_RIF (f
)->scroll_run_hook (w
, &run
);
16788 FRAME_RIF (f
)->update_window_end_hook (w
, 0, 0);
16792 /* Terminal frame. In this case, dvpos gives the number of
16793 lines to scroll by; dvpos < 0 means scroll up. */
16795 = MATRIX_ROW_VPOS (first_unchanged_at_end_row
, w
->current_matrix
);
16796 int from
= WINDOW_TOP_EDGE_LINE (w
) + from_vpos
;
16797 int end
= (WINDOW_TOP_EDGE_LINE (w
)
16798 + (WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0)
16799 + window_internal_height (w
));
16801 #if defined (HAVE_GPM) || defined (MSDOS)
16802 x_clear_window_mouse_face (w
);
16804 /* Perform the operation on the screen. */
16807 /* Scroll last_unchanged_at_beg_row to the end of the
16808 window down dvpos lines. */
16809 set_terminal_window (f
, end
);
16811 /* On dumb terminals delete dvpos lines at the end
16812 before inserting dvpos empty lines. */
16813 if (!FRAME_SCROLL_REGION_OK (f
))
16814 ins_del_lines (f
, end
- dvpos
, -dvpos
);
16816 /* Insert dvpos empty lines in front of
16817 last_unchanged_at_beg_row. */
16818 ins_del_lines (f
, from
, dvpos
);
16820 else if (dvpos
< 0)
16822 /* Scroll up last_unchanged_at_beg_vpos to the end of
16823 the window to last_unchanged_at_beg_vpos - |dvpos|. */
16824 set_terminal_window (f
, end
);
16826 /* Delete dvpos lines in front of
16827 last_unchanged_at_beg_vpos. ins_del_lines will set
16828 the cursor to the given vpos and emit |dvpos| delete
16830 ins_del_lines (f
, from
+ dvpos
, dvpos
);
16832 /* On a dumb terminal insert dvpos empty lines at the
16834 if (!FRAME_SCROLL_REGION_OK (f
))
16835 ins_del_lines (f
, end
+ dvpos
, -dvpos
);
16838 set_terminal_window (f
, 0);
16844 /* Shift reused rows of the current matrix to the right position.
16845 BOTTOM_ROW is the last + 1 row in the current matrix reserved for
16847 bottom_row
= MATRIX_BOTTOM_TEXT_ROW (current_matrix
, w
);
16848 bottom_vpos
= MATRIX_ROW_VPOS (bottom_row
, current_matrix
);
16851 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
+ dvpos
,
16852 bottom_vpos
, dvpos
);
16853 enable_glyph_matrix_rows (current_matrix
, bottom_vpos
+ dvpos
,
16856 else if (dvpos
> 0)
16858 rotate_matrix (current_matrix
, first_unchanged_at_end_vpos
,
16859 bottom_vpos
, dvpos
);
16860 enable_glyph_matrix_rows (current_matrix
, first_unchanged_at_end_vpos
,
16861 first_unchanged_at_end_vpos
+ dvpos
, 0);
16864 /* For frame-based redisplay, make sure that current frame and window
16865 matrix are in sync with respect to glyph memory. */
16866 if (!FRAME_WINDOW_P (f
))
16867 sync_frame_with_window_matrix_rows (w
);
16869 /* Adjust buffer positions in reused rows. */
16870 if (delta
|| delta_bytes
)
16871 increment_matrix_positions (current_matrix
,
16872 first_unchanged_at_end_vpos
+ dvpos
,
16873 bottom_vpos
, delta
, delta_bytes
);
16875 /* Adjust Y positions. */
16877 shift_glyph_matrix (w
, current_matrix
,
16878 first_unchanged_at_end_vpos
+ dvpos
,
16881 if (first_unchanged_at_end_row
)
16883 first_unchanged_at_end_row
+= dvpos
;
16884 if (first_unchanged_at_end_row
->y
>= it
.last_visible_y
16885 || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row
))
16886 first_unchanged_at_end_row
= NULL
;
16889 /* If scrolling up, there may be some lines to display at the end of
16891 last_text_row_at_end
= NULL
;
16894 /* Scrolling up can leave for example a partially visible line
16895 at the end of the window to be redisplayed. */
16896 /* Set last_row to the glyph row in the current matrix where the
16897 window end line is found. It has been moved up or down in
16898 the matrix by dvpos. */
16899 int last_vpos
= XFASTINT (w
->window_end_vpos
) + dvpos
;
16900 struct glyph_row
*last_row
= MATRIX_ROW (current_matrix
, last_vpos
);
16902 /* If last_row is the window end line, it should display text. */
16903 xassert (last_row
->displays_text_p
);
16905 /* If window end line was partially visible before, begin
16906 displaying at that line. Otherwise begin displaying with the
16907 line following it. */
16908 if (MATRIX_ROW_BOTTOM_Y (last_row
) - dy
>= it
.last_visible_y
)
16910 init_to_row_start (&it
, w
, last_row
);
16911 it
.vpos
= last_vpos
;
16912 it
.current_y
= last_row
->y
;
16916 init_to_row_end (&it
, w
, last_row
);
16917 it
.vpos
= 1 + last_vpos
;
16918 it
.current_y
= MATRIX_ROW_BOTTOM_Y (last_row
);
16922 /* We may start in a continuation line. If so, we have to
16923 get the right continuation_lines_width and current_x. */
16924 it
.continuation_lines_width
= last_row
->continuation_lines_width
;
16925 it
.hpos
= it
.current_x
= 0;
16927 /* Display the rest of the lines at the window end. */
16928 it
.glyph_row
= MATRIX_ROW (desired_matrix
, it
.vpos
);
16929 while (it
.current_y
< it
.last_visible_y
16930 && !fonts_changed_p
)
16932 /* Is it always sure that the display agrees with lines in
16933 the current matrix? I don't think so, so we mark rows
16934 displayed invalid in the current matrix by setting their
16935 enabled_p flag to zero. */
16936 MATRIX_ROW (w
->current_matrix
, it
.vpos
)->enabled_p
= 0;
16937 if (display_line (&it
))
16938 last_text_row_at_end
= it
.glyph_row
- 1;
16942 /* Update window_end_pos and window_end_vpos. */
16943 if (first_unchanged_at_end_row
16944 && !last_text_row_at_end
)
16946 /* Window end line if one of the preserved rows from the current
16947 matrix. Set row to the last row displaying text in current
16948 matrix starting at first_unchanged_at_end_row, after
16950 xassert (first_unchanged_at_end_row
->displays_text_p
);
16951 row
= find_last_row_displaying_text (w
->current_matrix
, &it
,
16952 first_unchanged_at_end_row
);
16953 xassert (row
&& MATRIX_ROW_DISPLAYS_TEXT_P (row
));
16955 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
16956 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
16958 = make_number (MATRIX_ROW_VPOS (row
, w
->current_matrix
));
16959 xassert (w
->window_end_bytepos
>= 0);
16960 IF_DEBUG (debug_method_add (w
, "A"));
16962 else if (last_text_row_at_end
)
16965 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row_at_end
));
16966 w
->window_end_bytepos
16967 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row_at_end
);
16969 = make_number (MATRIX_ROW_VPOS (last_text_row_at_end
, desired_matrix
));
16970 xassert (w
->window_end_bytepos
>= 0);
16971 IF_DEBUG (debug_method_add (w
, "B"));
16973 else if (last_text_row
)
16975 /* We have displayed either to the end of the window or at the
16976 end of the window, i.e. the last row with text is to be found
16977 in the desired matrix. */
16979 = make_number (Z
- MATRIX_ROW_END_CHARPOS (last_text_row
));
16980 w
->window_end_bytepos
16981 = Z_BYTE
- MATRIX_ROW_END_BYTEPOS (last_text_row
);
16983 = make_number (MATRIX_ROW_VPOS (last_text_row
, desired_matrix
));
16984 xassert (w
->window_end_bytepos
>= 0);
16986 else if (first_unchanged_at_end_row
== NULL
16987 && last_text_row
== NULL
16988 && last_text_row_at_end
== NULL
)
16990 /* Displayed to end of window, but no line containing text was
16991 displayed. Lines were deleted at the end of the window. */
16992 int first_vpos
= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
16993 int vpos
= XFASTINT (w
->window_end_vpos
);
16994 struct glyph_row
*current_row
= current_matrix
->rows
+ vpos
;
16995 struct glyph_row
*desired_row
= desired_matrix
->rows
+ vpos
;
16998 row
== NULL
&& vpos
>= first_vpos
;
16999 --vpos
, --current_row
, --desired_row
)
17001 if (desired_row
->enabled_p
)
17003 if (desired_row
->displays_text_p
)
17006 else if (current_row
->displays_text_p
)
17010 xassert (row
!= NULL
);
17011 w
->window_end_vpos
= make_number (vpos
+ 1);
17012 w
->window_end_pos
= make_number (Z
- MATRIX_ROW_END_CHARPOS (row
));
17013 w
->window_end_bytepos
= Z_BYTE
- MATRIX_ROW_END_BYTEPOS (row
);
17014 xassert (w
->window_end_bytepos
>= 0);
17015 IF_DEBUG (debug_method_add (w
, "C"));
17020 IF_DEBUG (debug_end_pos
= XFASTINT (w
->window_end_pos
);
17021 debug_end_vpos
= XFASTINT (w
->window_end_vpos
));
17023 /* Record that display has not been completed. */
17024 w
->window_end_valid
= Qnil
;
17025 w
->desired_matrix
->no_scrolling_p
= 1;
17033 /***********************************************************************
17034 More debugging support
17035 ***********************************************************************/
17039 void dump_glyph_row (struct glyph_row
*, int, int);
17040 void dump_glyph_matrix (struct glyph_matrix
*, int);
17041 void dump_glyph (struct glyph_row
*, struct glyph
*, int);
17044 /* Dump the contents of glyph matrix MATRIX on stderr.
17046 GLYPHS 0 means don't show glyph contents.
17047 GLYPHS 1 means show glyphs in short form
17048 GLYPHS > 1 means show glyphs in long form. */
17051 dump_glyph_matrix (matrix
, glyphs
)
17052 struct glyph_matrix
*matrix
;
17056 for (i
= 0; i
< matrix
->nrows
; ++i
)
17057 dump_glyph_row (MATRIX_ROW (matrix
, i
), i
, glyphs
);
17061 /* Dump contents of glyph GLYPH to stderr. ROW and AREA are
17062 the glyph row and area where the glyph comes from. */
17065 dump_glyph (row
, glyph
, area
)
17066 struct glyph_row
*row
;
17067 struct glyph
*glyph
;
17070 if (glyph
->type
== CHAR_GLYPH
)
17073 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17074 glyph
- row
->glyphs
[TEXT_AREA
],
17077 (BUFFERP (glyph
->object
)
17079 : (STRINGP (glyph
->object
)
17082 glyph
->pixel_width
,
17084 (glyph
->u
.ch
< 0x80 && glyph
->u
.ch
>= ' '
17088 glyph
->left_box_line_p
,
17089 glyph
->right_box_line_p
);
17091 else if (glyph
->type
== STRETCH_GLYPH
)
17094 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17095 glyph
- row
->glyphs
[TEXT_AREA
],
17098 (BUFFERP (glyph
->object
)
17100 : (STRINGP (glyph
->object
)
17103 glyph
->pixel_width
,
17107 glyph
->left_box_line_p
,
17108 glyph
->right_box_line_p
);
17110 else if (glyph
->type
== IMAGE_GLYPH
)
17113 " %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
17114 glyph
- row
->glyphs
[TEXT_AREA
],
17117 (BUFFERP (glyph
->object
)
17119 : (STRINGP (glyph
->object
)
17122 glyph
->pixel_width
,
17126 glyph
->left_box_line_p
,
17127 glyph
->right_box_line_p
);
17129 else if (glyph
->type
== COMPOSITE_GLYPH
)
17132 " %5d %4c %6d %c %3d 0x%05x",
17133 glyph
- row
->glyphs
[TEXT_AREA
],
17136 (BUFFERP (glyph
->object
)
17138 : (STRINGP (glyph
->object
)
17141 glyph
->pixel_width
,
17143 if (glyph
->u
.cmp
.automatic
)
17146 glyph
->slice
.cmp
.from
, glyph
->slice
.cmp
.to
);
17147 fprintf (stderr
, " . %4d %1.1d%1.1d\n",
17149 glyph
->left_box_line_p
,
17150 glyph
->right_box_line_p
);
17155 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
17156 GLYPHS 0 means don't show glyph contents.
17157 GLYPHS 1 means show glyphs in short form
17158 GLYPHS > 1 means show glyphs in long form. */
17161 dump_glyph_row (row
, vpos
, glyphs
)
17162 struct glyph_row
*row
;
17167 fprintf (stderr
, "Row Start End Used oE><\\CTZFesm X Y W H V A P\n");
17168 fprintf (stderr
, "======================================================================\n");
17170 fprintf (stderr
, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
17171 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d %4d %4d %4d %4d %4d %4d %4d\n",
17173 MATRIX_ROW_START_CHARPOS (row
),
17174 MATRIX_ROW_END_CHARPOS (row
),
17175 row
->used
[TEXT_AREA
],
17176 row
->contains_overlapping_glyphs_p
,
17178 row
->truncated_on_left_p
,
17179 row
->truncated_on_right_p
,
17181 MATRIX_ROW_CONTINUATION_LINE_P (row
),
17182 row
->displays_text_p
,
17185 row
->ends_in_middle_of_char_p
,
17186 row
->starts_in_middle_of_char_p
,
17192 row
->visible_height
,
17195 fprintf (stderr
, "%9d %5d\t%5d\n", row
->start
.overlay_string_index
,
17196 row
->end
.overlay_string_index
,
17197 row
->continuation_lines_width
);
17198 fprintf (stderr
, "%9d %5d\n",
17199 CHARPOS (row
->start
.string_pos
),
17200 CHARPOS (row
->end
.string_pos
));
17201 fprintf (stderr
, "%9d %5d\n", row
->start
.dpvec_index
,
17202 row
->end
.dpvec_index
);
17209 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
17211 struct glyph
*glyph
= row
->glyphs
[area
];
17212 struct glyph
*glyph_end
= glyph
+ row
->used
[area
];
17214 /* Glyph for a line end in text. */
17215 if (area
== TEXT_AREA
&& glyph
== glyph_end
&& glyph
->charpos
> 0)
17218 if (glyph
< glyph_end
)
17219 fprintf (stderr
, " Glyph Type Pos O W Code C Face LR\n");
17221 for (; glyph
< glyph_end
; ++glyph
)
17222 dump_glyph (row
, glyph
, area
);
17225 else if (glyphs
== 1)
17229 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
17231 char *s
= (char *) alloca (row
->used
[area
] + 1);
17234 for (i
= 0; i
< row
->used
[area
]; ++i
)
17236 struct glyph
*glyph
= row
->glyphs
[area
] + i
;
17237 if (glyph
->type
== CHAR_GLYPH
17238 && glyph
->u
.ch
< 0x80
17239 && glyph
->u
.ch
>= ' ')
17240 s
[i
] = glyph
->u
.ch
;
17246 fprintf (stderr
, "%3d: (%d) '%s'\n", vpos
, row
->enabled_p
, s
);
17252 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix
,
17253 Sdump_glyph_matrix
, 0, 1, "p",
17254 doc
: /* Dump the current matrix of the selected window to stderr.
17255 Shows contents of glyph row structures. With non-nil
17256 parameter GLYPHS, dump glyphs as well. If GLYPHS is 1 show
17257 glyphs in short form, otherwise show glyphs in long form. */)
17258 (Lisp_Object glyphs
)
17260 struct window
*w
= XWINDOW (selected_window
);
17261 struct buffer
*buffer
= XBUFFER (w
->buffer
);
17263 fprintf (stderr
, "PT = %d, BEGV = %d. ZV = %d\n",
17264 BUF_PT (buffer
), BUF_BEGV (buffer
), BUF_ZV (buffer
));
17265 fprintf (stderr
, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
17266 w
->cursor
.x
, w
->cursor
.y
, w
->cursor
.hpos
, w
->cursor
.vpos
);
17267 fprintf (stderr
, "=============================================\n");
17268 dump_glyph_matrix (w
->current_matrix
,
17269 NILP (glyphs
) ? 0 : XINT (glyphs
));
17274 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix
,
17275 Sdump_frame_glyph_matrix
, 0, 0, "", doc
: /* */)
17278 struct frame
*f
= XFRAME (selected_frame
);
17279 dump_glyph_matrix (f
->current_matrix
, 1);
17284 DEFUN ("dump-glyph-row", Fdump_glyph_row
, Sdump_glyph_row
, 1, 2, "",
17285 doc
: /* Dump glyph row ROW to stderr.
17286 GLYPH 0 means don't dump glyphs.
17287 GLYPH 1 means dump glyphs in short form.
17288 GLYPH > 1 or omitted means dump glyphs in long form. */)
17289 (Lisp_Object row
, Lisp_Object glyphs
)
17291 struct glyph_matrix
*matrix
;
17294 CHECK_NUMBER (row
);
17295 matrix
= XWINDOW (selected_window
)->current_matrix
;
17297 if (vpos
>= 0 && vpos
< matrix
->nrows
)
17298 dump_glyph_row (MATRIX_ROW (matrix
, vpos
),
17300 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
17305 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row
, Sdump_tool_bar_row
, 1, 2, "",
17306 doc
: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
17307 GLYPH 0 means don't dump glyphs.
17308 GLYPH 1 means dump glyphs in short form.
17309 GLYPH > 1 or omitted means dump glyphs in long form. */)
17310 (Lisp_Object row
, Lisp_Object glyphs
)
17312 struct frame
*sf
= SELECTED_FRAME ();
17313 struct glyph_matrix
*m
= XWINDOW (sf
->tool_bar_window
)->current_matrix
;
17316 CHECK_NUMBER (row
);
17318 if (vpos
>= 0 && vpos
< m
->nrows
)
17319 dump_glyph_row (MATRIX_ROW (m
, vpos
), vpos
,
17320 INTEGERP (glyphs
) ? XINT (glyphs
) : 2);
17325 DEFUN ("trace-redisplay", Ftrace_redisplay
, Strace_redisplay
, 0, 1, "P",
17326 doc
: /* Toggle tracing of redisplay.
17327 With ARG, turn tracing on if and only if ARG is positive. */)
17331 trace_redisplay_p
= !trace_redisplay_p
;
17334 arg
= Fprefix_numeric_value (arg
);
17335 trace_redisplay_p
= XINT (arg
) > 0;
17342 DEFUN ("trace-to-stderr", Ftrace_to_stderr
, Strace_to_stderr
, 1, MANY
, "",
17343 doc
: /* Like `format', but print result to stderr.
17344 usage: (trace-to-stderr STRING &rest OBJECTS) */)
17345 (size_t nargs
, Lisp_Object
*args
)
17347 Lisp_Object s
= Fformat (nargs
, args
);
17348 fprintf (stderr
, "%s", SDATA (s
));
17352 #endif /* GLYPH_DEBUG */
17356 /***********************************************************************
17357 Building Desired Matrix Rows
17358 ***********************************************************************/
17360 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
17361 Used for non-window-redisplay windows, and for windows w/o left fringe. */
17363 static struct glyph_row
*
17364 get_overlay_arrow_glyph_row (struct window
*w
, Lisp_Object overlay_arrow_string
)
17366 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
17367 struct buffer
*buffer
= XBUFFER (w
->buffer
);
17368 struct buffer
*old
= current_buffer
;
17369 const unsigned char *arrow_string
= SDATA (overlay_arrow_string
);
17370 int arrow_len
= SCHARS (overlay_arrow_string
);
17371 const unsigned char *arrow_end
= arrow_string
+ arrow_len
;
17372 const unsigned char *p
;
17375 int n_glyphs_before
;
17377 set_buffer_temp (buffer
);
17378 init_iterator (&it
, w
, -1, -1, &scratch_glyph_row
, DEFAULT_FACE_ID
);
17379 it
.glyph_row
->used
[TEXT_AREA
] = 0;
17380 SET_TEXT_POS (it
.position
, 0, 0);
17382 multibyte_p
= !NILP (BVAR (buffer
, enable_multibyte_characters
));
17384 while (p
< arrow_end
)
17386 Lisp_Object face
, ilisp
;
17388 /* Get the next character. */
17390 it
.c
= it
.char_to_display
= string_char_and_length (p
, &it
.len
);
17393 it
.c
= it
.char_to_display
= *p
, it
.len
= 1;
17394 if (! ASCII_CHAR_P (it
.c
))
17395 it
.char_to_display
= BYTE8_TO_CHAR (it
.c
);
17399 /* Get its face. */
17400 ilisp
= make_number (p
- arrow_string
);
17401 face
= Fget_text_property (ilisp
, Qface
, overlay_arrow_string
);
17402 it
.face_id
= compute_char_face (f
, it
.char_to_display
, face
);
17404 /* Compute its width, get its glyphs. */
17405 n_glyphs_before
= it
.glyph_row
->used
[TEXT_AREA
];
17406 SET_TEXT_POS (it
.position
, -1, -1);
17407 PRODUCE_GLYPHS (&it
);
17409 /* If this character doesn't fit any more in the line, we have
17410 to remove some glyphs. */
17411 if (it
.current_x
> it
.last_visible_x
)
17413 it
.glyph_row
->used
[TEXT_AREA
] = n_glyphs_before
;
17418 set_buffer_temp (old
);
17419 return it
.glyph_row
;
17423 /* Insert truncation glyphs at the start of IT->glyph_row. Truncation
17424 glyphs are only inserted for terminal frames since we can't really
17425 win with truncation glyphs when partially visible glyphs are
17426 involved. Which glyphs to insert is determined by
17427 produce_special_glyphs. */
17430 insert_left_trunc_glyphs (struct it
*it
)
17432 struct it truncate_it
;
17433 struct glyph
*from
, *end
, *to
, *toend
;
17435 xassert (!FRAME_WINDOW_P (it
->f
));
17437 /* Get the truncation glyphs. */
17439 truncate_it
.current_x
= 0;
17440 truncate_it
.face_id
= DEFAULT_FACE_ID
;
17441 truncate_it
.glyph_row
= &scratch_glyph_row
;
17442 truncate_it
.glyph_row
->used
[TEXT_AREA
] = 0;
17443 CHARPOS (truncate_it
.position
) = BYTEPOS (truncate_it
.position
) = -1;
17444 truncate_it
.object
= make_number (0);
17445 produce_special_glyphs (&truncate_it
, IT_TRUNCATION
);
17447 /* Overwrite glyphs from IT with truncation glyphs. */
17448 if (!it
->glyph_row
->reversed_p
)
17450 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
17451 end
= from
+ truncate_it
.glyph_row
->used
[TEXT_AREA
];
17452 to
= it
->glyph_row
->glyphs
[TEXT_AREA
];
17453 toend
= to
+ it
->glyph_row
->used
[TEXT_AREA
];
17458 /* There may be padding glyphs left over. Overwrite them too. */
17459 while (to
< toend
&& CHAR_GLYPH_PADDING_P (*to
))
17461 from
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
17467 it
->glyph_row
->used
[TEXT_AREA
] = to
- it
->glyph_row
->glyphs
[TEXT_AREA
];
17471 /* In R2L rows, overwrite the last (rightmost) glyphs, and do
17472 that back to front. */
17473 end
= truncate_it
.glyph_row
->glyphs
[TEXT_AREA
];
17474 from
= end
+ truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
17475 toend
= it
->glyph_row
->glyphs
[TEXT_AREA
];
17476 to
= toend
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
17478 while (from
>= end
&& to
>= toend
)
17480 while (to
>= toend
&& CHAR_GLYPH_PADDING_P (*to
))
17483 truncate_it
.glyph_row
->glyphs
[TEXT_AREA
]
17484 + truncate_it
.glyph_row
->used
[TEXT_AREA
] - 1;
17485 while (from
>= end
&& to
>= toend
)
17490 /* Need to free some room before prepending additional
17492 int move_by
= from
- end
+ 1;
17493 struct glyph
*g0
= it
->glyph_row
->glyphs
[TEXT_AREA
];
17494 struct glyph
*g
= g0
+ it
->glyph_row
->used
[TEXT_AREA
] - 1;
17496 for ( ; g
>= g0
; g
--)
17498 while (from
>= end
)
17500 it
->glyph_row
->used
[TEXT_AREA
] += move_by
;
17506 /* Compute the pixel height and width of IT->glyph_row.
17508 Most of the time, ascent and height of a display line will be equal
17509 to the max_ascent and max_height values of the display iterator
17510 structure. This is not the case if
17512 1. We hit ZV without displaying anything. In this case, max_ascent
17513 and max_height will be zero.
17515 2. We have some glyphs that don't contribute to the line height.
17516 (The glyph row flag contributes_to_line_height_p is for future
17517 pixmap extensions).
17519 The first case is easily covered by using default values because in
17520 these cases, the line height does not really matter, except that it
17521 must not be zero. */
17524 compute_line_metrics (struct it
*it
)
17526 struct glyph_row
*row
= it
->glyph_row
;
17528 if (FRAME_WINDOW_P (it
->f
))
17530 int i
, min_y
, max_y
;
17532 /* The line may consist of one space only, that was added to
17533 place the cursor on it. If so, the row's height hasn't been
17535 if (row
->height
== 0)
17537 if (it
->max_ascent
+ it
->max_descent
== 0)
17538 it
->max_descent
= it
->max_phys_descent
= FRAME_LINE_HEIGHT (it
->f
);
17539 row
->ascent
= it
->max_ascent
;
17540 row
->height
= it
->max_ascent
+ it
->max_descent
;
17541 row
->phys_ascent
= it
->max_phys_ascent
;
17542 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
17543 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
17546 /* Compute the width of this line. */
17547 row
->pixel_width
= row
->x
;
17548 for (i
= 0; i
< row
->used
[TEXT_AREA
]; ++i
)
17549 row
->pixel_width
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
17551 xassert (row
->pixel_width
>= 0);
17552 xassert (row
->ascent
>= 0 && row
->height
> 0);
17554 row
->overlapping_p
= (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
17555 || MATRIX_ROW_OVERLAPS_PRED_P (row
));
17557 /* If first line's physical ascent is larger than its logical
17558 ascent, use the physical ascent, and make the row taller.
17559 This makes accented characters fully visible. */
17560 if (row
== MATRIX_FIRST_TEXT_ROW (it
->w
->desired_matrix
)
17561 && row
->phys_ascent
> row
->ascent
)
17563 row
->height
+= row
->phys_ascent
- row
->ascent
;
17564 row
->ascent
= row
->phys_ascent
;
17567 /* Compute how much of the line is visible. */
17568 row
->visible_height
= row
->height
;
17570 min_y
= WINDOW_HEADER_LINE_HEIGHT (it
->w
);
17571 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
);
17573 if (row
->y
< min_y
)
17574 row
->visible_height
-= min_y
- row
->y
;
17575 if (row
->y
+ row
->height
> max_y
)
17576 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
17580 row
->pixel_width
= row
->used
[TEXT_AREA
];
17581 if (row
->continued_p
)
17582 row
->pixel_width
-= it
->continuation_pixel_width
;
17583 else if (row
->truncated_on_right_p
)
17584 row
->pixel_width
-= it
->truncation_pixel_width
;
17585 row
->ascent
= row
->phys_ascent
= 0;
17586 row
->height
= row
->phys_height
= row
->visible_height
= 1;
17587 row
->extra_line_spacing
= 0;
17590 /* Compute a hash code for this row. */
17594 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
17595 for (i
= 0; i
< row
->used
[area
]; ++i
)
17596 row
->hash
= ((((row
->hash
<< 4) + (row
->hash
>> 24)) & 0x0fffffff)
17597 + row
->glyphs
[area
][i
].u
.val
17598 + row
->glyphs
[area
][i
].face_id
17599 + row
->glyphs
[area
][i
].padding_p
17600 + (row
->glyphs
[area
][i
].type
<< 2));
17603 it
->max_ascent
= it
->max_descent
= 0;
17604 it
->max_phys_ascent
= it
->max_phys_descent
= 0;
17608 /* Append one space to the glyph row of iterator IT if doing a
17609 window-based redisplay. The space has the same face as
17610 IT->face_id. Value is non-zero if a space was added.
17612 This function is called to make sure that there is always one glyph
17613 at the end of a glyph row that the cursor can be set on under
17614 window-systems. (If there weren't such a glyph we would not know
17615 how wide and tall a box cursor should be displayed).
17617 At the same time this space let's a nicely handle clearing to the
17618 end of the line if the row ends in italic text. */
17621 append_space_for_newline (struct it
*it
, int default_face_p
)
17623 if (FRAME_WINDOW_P (it
->f
))
17625 int n
= it
->glyph_row
->used
[TEXT_AREA
];
17627 if (it
->glyph_row
->glyphs
[TEXT_AREA
] + n
17628 < it
->glyph_row
->glyphs
[1 + TEXT_AREA
])
17630 /* Save some values that must not be changed.
17631 Must save IT->c and IT->len because otherwise
17632 ITERATOR_AT_END_P wouldn't work anymore after
17633 append_space_for_newline has been called. */
17634 enum display_element_type saved_what
= it
->what
;
17635 int saved_c
= it
->c
, saved_len
= it
->len
;
17636 int saved_char_to_display
= it
->char_to_display
;
17637 int saved_x
= it
->current_x
;
17638 int saved_face_id
= it
->face_id
;
17639 struct text_pos saved_pos
;
17640 Lisp_Object saved_object
;
17643 saved_object
= it
->object
;
17644 saved_pos
= it
->position
;
17646 it
->what
= IT_CHARACTER
;
17647 memset (&it
->position
, 0, sizeof it
->position
);
17648 it
->object
= make_number (0);
17649 it
->c
= it
->char_to_display
= ' ';
17652 if (default_face_p
)
17653 it
->face_id
= DEFAULT_FACE_ID
;
17654 else if (it
->face_before_selective_p
)
17655 it
->face_id
= it
->saved_face_id
;
17656 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
17657 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, 0, -1, Qnil
);
17659 PRODUCE_GLYPHS (it
);
17661 it
->override_ascent
= -1;
17662 it
->constrain_row_ascent_descent_p
= 0;
17663 it
->current_x
= saved_x
;
17664 it
->object
= saved_object
;
17665 it
->position
= saved_pos
;
17666 it
->what
= saved_what
;
17667 it
->face_id
= saved_face_id
;
17668 it
->len
= saved_len
;
17670 it
->char_to_display
= saved_char_to_display
;
17679 /* Extend the face of the last glyph in the text area of IT->glyph_row
17680 to the end of the display line. Called from display_line. If the
17681 glyph row is empty, add a space glyph to it so that we know the
17682 face to draw. Set the glyph row flag fill_line_p. If the glyph
17683 row is R2L, prepend a stretch glyph to cover the empty space to the
17684 left of the leftmost glyph. */
17687 extend_face_to_end_of_line (struct it
*it
)
17690 struct frame
*f
= it
->f
;
17692 /* If line is already filled, do nothing. Non window-system frames
17693 get a grace of one more ``pixel'' because their characters are
17694 1-``pixel'' wide, so they hit the equality too early. This grace
17695 is needed only for R2L rows that are not continued, to produce
17696 one extra blank where we could display the cursor. */
17697 if (it
->current_x
>= it
->last_visible_x
17698 + (!FRAME_WINDOW_P (f
)
17699 && it
->glyph_row
->reversed_p
17700 && !it
->glyph_row
->continued_p
))
17703 /* Face extension extends the background and box of IT->face_id
17704 to the end of the line. If the background equals the background
17705 of the frame, we don't have to do anything. */
17706 if (it
->face_before_selective_p
)
17707 face
= FACE_FROM_ID (f
, it
->saved_face_id
);
17709 face
= FACE_FROM_ID (f
, it
->face_id
);
17711 if (FRAME_WINDOW_P (f
)
17712 && it
->glyph_row
->displays_text_p
17713 && face
->box
== FACE_NO_BOX
17714 && face
->background
== FRAME_BACKGROUND_PIXEL (f
)
17716 && !it
->glyph_row
->reversed_p
)
17719 /* Set the glyph row flag indicating that the face of the last glyph
17720 in the text area has to be drawn to the end of the text area. */
17721 it
->glyph_row
->fill_line_p
= 1;
17723 /* If current character of IT is not ASCII, make sure we have the
17724 ASCII face. This will be automatically undone the next time
17725 get_next_display_element returns a multibyte character. Note
17726 that the character will always be single byte in unibyte
17728 if (!ASCII_CHAR_P (it
->c
))
17730 it
->face_id
= FACE_FOR_CHAR (f
, face
, 0, -1, Qnil
);
17733 if (FRAME_WINDOW_P (f
))
17735 /* If the row is empty, add a space with the current face of IT,
17736 so that we know which face to draw. */
17737 if (it
->glyph_row
->used
[TEXT_AREA
] == 0)
17739 it
->glyph_row
->glyphs
[TEXT_AREA
][0] = space_glyph
;
17740 it
->glyph_row
->glyphs
[TEXT_AREA
][0].face_id
= it
->face_id
;
17741 it
->glyph_row
->used
[TEXT_AREA
] = 1;
17743 #ifdef HAVE_WINDOW_SYSTEM
17744 if (it
->glyph_row
->reversed_p
)
17746 /* Prepend a stretch glyph to the row, such that the
17747 rightmost glyph will be drawn flushed all the way to the
17748 right margin of the window. The stretch glyph that will
17749 occupy the empty space, if any, to the left of the
17751 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (f
);
17752 struct glyph
*row_start
= it
->glyph_row
->glyphs
[TEXT_AREA
];
17753 struct glyph
*row_end
= row_start
+ it
->glyph_row
->used
[TEXT_AREA
];
17755 int row_width
, stretch_ascent
, stretch_width
;
17756 struct text_pos saved_pos
;
17757 int saved_face_id
, saved_avoid_cursor
;
17759 for (row_width
= 0, g
= row_start
; g
< row_end
; g
++)
17760 row_width
+= g
->pixel_width
;
17761 stretch_width
= window_box_width (it
->w
, TEXT_AREA
) - row_width
;
17762 if (stretch_width
> 0)
17765 (((it
->ascent
+ it
->descent
)
17766 * FONT_BASE (font
)) / FONT_HEIGHT (font
));
17767 saved_pos
= it
->position
;
17768 memset (&it
->position
, 0, sizeof it
->position
);
17769 saved_avoid_cursor
= it
->avoid_cursor_p
;
17770 it
->avoid_cursor_p
= 1;
17771 saved_face_id
= it
->face_id
;
17772 /* The last row's stretch glyph should get the default
17773 face, to avoid painting the rest of the window with
17774 the region face, if the region ends at ZV. */
17775 if (it
->glyph_row
->ends_at_zv_p
)
17776 it
->face_id
= DEFAULT_FACE_ID
;
17778 it
->face_id
= face
->id
;
17779 append_stretch_glyph (it
, make_number (0), stretch_width
,
17780 it
->ascent
+ it
->descent
, stretch_ascent
);
17781 it
->position
= saved_pos
;
17782 it
->avoid_cursor_p
= saved_avoid_cursor
;
17783 it
->face_id
= saved_face_id
;
17786 #endif /* HAVE_WINDOW_SYSTEM */
17790 /* Save some values that must not be changed. */
17791 int saved_x
= it
->current_x
;
17792 struct text_pos saved_pos
;
17793 Lisp_Object saved_object
;
17794 enum display_element_type saved_what
= it
->what
;
17795 int saved_face_id
= it
->face_id
;
17797 saved_object
= it
->object
;
17798 saved_pos
= it
->position
;
17800 it
->what
= IT_CHARACTER
;
17801 memset (&it
->position
, 0, sizeof it
->position
);
17802 it
->object
= make_number (0);
17803 it
->c
= it
->char_to_display
= ' ';
17805 /* The last row's blank glyphs should get the default face, to
17806 avoid painting the rest of the window with the region face,
17807 if the region ends at ZV. */
17808 if (it
->glyph_row
->ends_at_zv_p
)
17809 it
->face_id
= DEFAULT_FACE_ID
;
17811 it
->face_id
= face
->id
;
17813 PRODUCE_GLYPHS (it
);
17815 while (it
->current_x
<= it
->last_visible_x
)
17816 PRODUCE_GLYPHS (it
);
17818 /* Don't count these blanks really. It would let us insert a left
17819 truncation glyph below and make us set the cursor on them, maybe. */
17820 it
->current_x
= saved_x
;
17821 it
->object
= saved_object
;
17822 it
->position
= saved_pos
;
17823 it
->what
= saved_what
;
17824 it
->face_id
= saved_face_id
;
17829 /* Value is non-zero if text starting at CHARPOS in current_buffer is
17830 trailing whitespace. */
17833 trailing_whitespace_p (EMACS_INT charpos
)
17835 EMACS_INT bytepos
= CHAR_TO_BYTE (charpos
);
17838 while (bytepos
< ZV_BYTE
17839 && (c
= FETCH_CHAR (bytepos
),
17840 c
== ' ' || c
== '\t'))
17843 if (bytepos
>= ZV_BYTE
|| c
== '\n' || c
== '\r')
17845 if (bytepos
!= PT_BYTE
)
17852 /* Highlight trailing whitespace, if any, in ROW. */
17855 highlight_trailing_whitespace (struct frame
*f
, struct glyph_row
*row
)
17857 int used
= row
->used
[TEXT_AREA
];
17861 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
17862 struct glyph
*glyph
= start
+ used
- 1;
17864 if (row
->reversed_p
)
17866 /* Right-to-left rows need to be processed in the opposite
17867 direction, so swap the edge pointers. */
17869 start
= row
->glyphs
[TEXT_AREA
] + used
- 1;
17872 /* Skip over glyphs inserted to display the cursor at the
17873 end of a line, for extending the face of the last glyph
17874 to the end of the line on terminals, and for truncation
17875 and continuation glyphs. */
17876 if (!row
->reversed_p
)
17878 while (glyph
>= start
17879 && glyph
->type
== CHAR_GLYPH
17880 && INTEGERP (glyph
->object
))
17885 while (glyph
<= start
17886 && glyph
->type
== CHAR_GLYPH
17887 && INTEGERP (glyph
->object
))
17891 /* If last glyph is a space or stretch, and it's trailing
17892 whitespace, set the face of all trailing whitespace glyphs in
17893 IT->glyph_row to `trailing-whitespace'. */
17894 if ((row
->reversed_p
? glyph
<= start
: glyph
>= start
)
17895 && BUFFERP (glyph
->object
)
17896 && (glyph
->type
== STRETCH_GLYPH
17897 || (glyph
->type
== CHAR_GLYPH
17898 && glyph
->u
.ch
== ' '))
17899 && trailing_whitespace_p (glyph
->charpos
))
17901 int face_id
= lookup_named_face (f
, Qtrailing_whitespace
, 0);
17905 if (!row
->reversed_p
)
17907 while (glyph
>= start
17908 && BUFFERP (glyph
->object
)
17909 && (glyph
->type
== STRETCH_GLYPH
17910 || (glyph
->type
== CHAR_GLYPH
17911 && glyph
->u
.ch
== ' ')))
17912 (glyph
--)->face_id
= face_id
;
17916 while (glyph
<= start
17917 && BUFFERP (glyph
->object
)
17918 && (glyph
->type
== STRETCH_GLYPH
17919 || (glyph
->type
== CHAR_GLYPH
17920 && glyph
->u
.ch
== ' ')))
17921 (glyph
++)->face_id
= face_id
;
17928 /* Value is non-zero if glyph row ROW should be
17929 used to hold the cursor. */
17932 cursor_row_p (struct glyph_row
*row
)
17936 if (PT
== CHARPOS (row
->end
.pos
))
17938 /* Suppose the row ends on a string.
17939 Unless the row is continued, that means it ends on a newline
17940 in the string. If it's anything other than a display string
17941 (e.g. a before-string from an overlay), we don't want the
17942 cursor there. (This heuristic seems to give the optimal
17943 behavior for the various types of multi-line strings.) */
17944 if (CHARPOS (row
->end
.string_pos
) >= 0)
17946 if (row
->continued_p
)
17950 /* Check for `display' property. */
17951 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
17952 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
] - 1;
17953 struct glyph
*glyph
;
17956 for (glyph
= end
; glyph
>= beg
; --glyph
)
17957 if (STRINGP (glyph
->object
))
17960 = Fget_char_property (make_number (PT
),
17964 && display_prop_string_p (prop
, glyph
->object
));
17969 else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))
17971 /* If the row ends in middle of a real character,
17972 and the line is continued, we want the cursor here.
17973 That's because CHARPOS (ROW->end.pos) would equal
17974 PT if PT is before the character. */
17975 if (!row
->ends_in_ellipsis_p
)
17976 result
= row
->continued_p
;
17978 /* If the row ends in an ellipsis, then
17979 CHARPOS (ROW->end.pos) will equal point after the
17980 invisible text. We want that position to be displayed
17981 after the ellipsis. */
17984 /* If the row ends at ZV, display the cursor at the end of that
17985 row instead of at the start of the row below. */
17986 else if (row
->ends_at_zv_p
)
17997 /* Push the display property PROP so that it will be rendered at the
17998 current position in IT. Return 1 if PROP was successfully pushed,
18002 push_display_prop (struct it
*it
, Lisp_Object prop
)
18004 xassert (it
->method
== GET_FROM_BUFFER
);
18006 push_it (it
, NULL
);
18008 if (STRINGP (prop
))
18010 if (SCHARS (prop
) == 0)
18017 it
->multibyte_p
= STRING_MULTIBYTE (it
->string
);
18018 it
->current
.overlay_string_index
= -1;
18019 IT_STRING_CHARPOS (*it
) = IT_STRING_BYTEPOS (*it
) = 0;
18020 it
->end_charpos
= it
->string_nchars
= SCHARS (it
->string
);
18021 it
->method
= GET_FROM_STRING
;
18022 it
->stop_charpos
= 0;
18024 it
->base_level_stop
= 0;
18025 it
->string_from_display_prop_p
= 1;
18026 it
->from_disp_prop_p
= 1;
18028 /* Force paragraph direction to be that of the parent
18030 if (it
->bidi_p
&& it
->bidi_it
.paragraph_dir
== R2L
)
18031 it
->paragraph_embedding
= it
->bidi_it
.paragraph_dir
;
18033 it
->paragraph_embedding
= L2R
;
18035 /* Set up the bidi iterator for this display string. */
18038 it
->bidi_it
.string
.lstring
= it
->string
;
18039 it
->bidi_it
.string
.s
= NULL
;
18040 it
->bidi_it
.string
.schars
= it
->end_charpos
;
18041 it
->bidi_it
.string
.bufpos
= IT_CHARPOS (*it
);
18042 it
->bidi_it
.string
.from_disp_str
= 1;
18043 it
->bidi_it
.string
.unibyte
= !it
->multibyte_p
;
18044 bidi_init_it (0, 0, FRAME_WINDOW_P (it
->f
), &it
->bidi_it
);
18047 else if (CONSP (prop
) && EQ (XCAR (prop
), Qspace
))
18049 it
->method
= GET_FROM_STRETCH
;
18052 #ifdef HAVE_WINDOW_SYSTEM
18053 else if (IMAGEP (prop
))
18055 it
->what
= IT_IMAGE
;
18056 it
->image_id
= lookup_image (it
->f
, prop
);
18057 it
->method
= GET_FROM_IMAGE
;
18059 #endif /* HAVE_WINDOW_SYSTEM */
18062 pop_it (it
); /* bogus display property, give up */
18069 /* Return the character-property PROP at the current position in IT. */
18072 get_it_property (struct it
*it
, Lisp_Object prop
)
18074 Lisp_Object position
;
18076 if (STRINGP (it
->object
))
18077 position
= make_number (IT_STRING_CHARPOS (*it
));
18078 else if (BUFFERP (it
->object
))
18079 position
= make_number (IT_CHARPOS (*it
));
18083 return Fget_char_property (position
, prop
, it
->object
);
18086 /* See if there's a line- or wrap-prefix, and if so, push it on IT. */
18089 handle_line_prefix (struct it
*it
)
18091 Lisp_Object prefix
;
18093 if (it
->continuation_lines_width
> 0)
18095 prefix
= get_it_property (it
, Qwrap_prefix
);
18097 prefix
= Vwrap_prefix
;
18101 prefix
= get_it_property (it
, Qline_prefix
);
18103 prefix
= Vline_prefix
;
18105 if (! NILP (prefix
) && push_display_prop (it
, prefix
))
18107 /* If the prefix is wider than the window, and we try to wrap
18108 it, it would acquire its own wrap prefix, and so on till the
18109 iterator stack overflows. So, don't wrap the prefix. */
18110 it
->line_wrap
= TRUNCATE
;
18111 it
->avoid_cursor_p
= 1;
18117 /* Remove N glyphs at the start of a reversed IT->glyph_row. Called
18118 only for R2L lines from display_line and display_string, when they
18119 decide that too many glyphs were produced by PRODUCE_GLYPHS, and
18120 the line/string needs to be continued on the next glyph row. */
18122 unproduce_glyphs (struct it
*it
, int n
)
18124 struct glyph
*glyph
, *end
;
18126 xassert (it
->glyph_row
);
18127 xassert (it
->glyph_row
->reversed_p
);
18128 xassert (it
->area
== TEXT_AREA
);
18129 xassert (n
<= it
->glyph_row
->used
[TEXT_AREA
]);
18131 if (n
> it
->glyph_row
->used
[TEXT_AREA
])
18132 n
= it
->glyph_row
->used
[TEXT_AREA
];
18133 glyph
= it
->glyph_row
->glyphs
[TEXT_AREA
] + n
;
18134 end
= it
->glyph_row
->glyphs
[TEXT_AREA
] + it
->glyph_row
->used
[TEXT_AREA
];
18135 for ( ; glyph
< end
; glyph
++)
18136 glyph
[-n
] = *glyph
;
18139 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
18140 and ROW->maxpos. */
18142 find_row_edges (struct it
*it
, struct glyph_row
*row
,
18143 EMACS_INT min_pos
, EMACS_INT min_bpos
,
18144 EMACS_INT max_pos
, EMACS_INT max_bpos
)
18146 /* FIXME: Revisit this when glyph ``spilling'' in continuation
18147 lines' rows is implemented for bidi-reordered rows. */
18149 /* ROW->minpos is the value of min_pos, the minimal buffer position
18150 we have in ROW, or ROW->start.pos if that is smaller. */
18151 if (min_pos
<= ZV
&& min_pos
< row
->start
.pos
.charpos
)
18152 SET_TEXT_POS (row
->minpos
, min_pos
, min_bpos
);
18154 /* We didn't find buffer positions smaller than ROW->start, or
18155 didn't find _any_ valid buffer positions in any of the glyphs,
18156 so we must trust the iterator's computed positions. */
18157 row
->minpos
= row
->start
.pos
;
18160 max_pos
= CHARPOS (it
->current
.pos
);
18161 max_bpos
= BYTEPOS (it
->current
.pos
);
18164 /* Here are the various use-cases for ending the row, and the
18165 corresponding values for ROW->maxpos:
18167 Line ends in a newline from buffer eol_pos + 1
18168 Line is continued from buffer max_pos + 1
18169 Line is truncated on right it->current.pos
18170 Line ends in a newline from string max_pos
18171 Line is continued from string max_pos
18172 Line is continued from display vector max_pos
18173 Line is entirely from a string min_pos == max_pos
18174 Line is entirely from a display vector min_pos == max_pos
18175 Line that ends at ZV ZV
18177 If you discover other use-cases, please add them here as
18179 if (row
->ends_at_zv_p
)
18180 row
->maxpos
= it
->current
.pos
;
18181 else if (row
->used
[TEXT_AREA
])
18183 if (row
->ends_in_newline_from_string_p
)
18184 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
18185 else if (CHARPOS (it
->eol_pos
) > 0)
18186 SET_TEXT_POS (row
->maxpos
,
18187 CHARPOS (it
->eol_pos
) + 1, BYTEPOS (it
->eol_pos
) + 1);
18188 else if (row
->continued_p
)
18190 /* If max_pos is different from IT's current position, it
18191 means IT->method does not belong to the display element
18192 at max_pos. However, it also means that the display
18193 element at max_pos was displayed in its entirety on this
18194 line, which is equivalent to saying that the next line
18195 starts at the next buffer position. */
18196 if (IT_CHARPOS (*it
) == max_pos
&& it
->method
!= GET_FROM_BUFFER
)
18197 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
18200 INC_BOTH (max_pos
, max_bpos
);
18201 SET_TEXT_POS (row
->maxpos
, max_pos
, max_bpos
);
18204 else if (row
->truncated_on_right_p
)
18205 /* display_line already called reseat_at_next_visible_line_start,
18206 which puts the iterator at the beginning of the next line, in
18207 the logical order. */
18208 row
->maxpos
= it
->current
.pos
;
18209 else if (max_pos
== min_pos
&& it
->method
!= GET_FROM_BUFFER
)
18210 /* A line that is entirely from a string/image/stretch... */
18211 row
->maxpos
= row
->minpos
;
18216 row
->maxpos
= it
->current
.pos
;
18219 /* Construct the glyph row IT->glyph_row in the desired matrix of
18220 IT->w from text at the current position of IT. See dispextern.h
18221 for an overview of struct it. Value is non-zero if
18222 IT->glyph_row displays text, as opposed to a line displaying ZV
18226 display_line (struct it
*it
)
18228 struct glyph_row
*row
= it
->glyph_row
;
18229 Lisp_Object overlay_arrow_string
;
18231 void *wrap_data
= NULL
;
18232 int may_wrap
= 0, wrap_x
IF_LINT (= 0);
18233 int wrap_row_used
= -1;
18234 int wrap_row_ascent
IF_LINT (= 0), wrap_row_height
IF_LINT (= 0);
18235 int wrap_row_phys_ascent
IF_LINT (= 0), wrap_row_phys_height
IF_LINT (= 0);
18236 int wrap_row_extra_line_spacing
IF_LINT (= 0);
18237 EMACS_INT wrap_row_min_pos
IF_LINT (= 0), wrap_row_min_bpos
IF_LINT (= 0);
18238 EMACS_INT wrap_row_max_pos
IF_LINT (= 0), wrap_row_max_bpos
IF_LINT (= 0);
18240 EMACS_INT min_pos
= ZV
+ 1, max_pos
= 0;
18241 EMACS_INT min_bpos
IF_LINT (= 0), max_bpos
IF_LINT (= 0);
18243 /* We always start displaying at hpos zero even if hscrolled. */
18244 xassert (it
->hpos
== 0 && it
->current_x
== 0);
18246 if (MATRIX_ROW_VPOS (row
, it
->w
->desired_matrix
)
18247 >= it
->w
->desired_matrix
->nrows
)
18249 it
->w
->nrows_scale_factor
++;
18250 fonts_changed_p
= 1;
18254 /* Is IT->w showing the region? */
18255 it
->w
->region_showing
= it
->region_beg_charpos
> 0 ? Qt
: Qnil
;
18257 /* Clear the result glyph row and enable it. */
18258 prepare_desired_row (row
);
18260 row
->y
= it
->current_y
;
18261 row
->start
= it
->start
;
18262 row
->continuation_lines_width
= it
->continuation_lines_width
;
18263 row
->displays_text_p
= 1;
18264 row
->starts_in_middle_of_char_p
= it
->starts_in_middle_of_char_p
;
18265 it
->starts_in_middle_of_char_p
= 0;
18267 /* Arrange the overlays nicely for our purposes. Usually, we call
18268 display_line on only one line at a time, in which case this
18269 can't really hurt too much, or we call it on lines which appear
18270 one after another in the buffer, in which case all calls to
18271 recenter_overlay_lists but the first will be pretty cheap. */
18272 recenter_overlay_lists (current_buffer
, IT_CHARPOS (*it
));
18274 /* Move over display elements that are not visible because we are
18275 hscrolled. This may stop at an x-position < IT->first_visible_x
18276 if the first glyph is partially visible or if we hit a line end. */
18277 if (it
->current_x
< it
->first_visible_x
)
18279 this_line_min_pos
= row
->start
.pos
;
18280 move_it_in_display_line_to (it
, ZV
, it
->first_visible_x
,
18281 MOVE_TO_POS
| MOVE_TO_X
);
18282 /* Record the smallest positions seen while we moved over
18283 display elements that are not visible. This is needed by
18284 redisplay_internal for optimizing the case where the cursor
18285 stays inside the same line. The rest of this function only
18286 considers positions that are actually displayed, so
18287 RECORD_MAX_MIN_POS will not otherwise record positions that
18288 are hscrolled to the left of the left edge of the window. */
18289 min_pos
= CHARPOS (this_line_min_pos
);
18290 min_bpos
= BYTEPOS (this_line_min_pos
);
18294 /* We only do this when not calling `move_it_in_display_line_to'
18295 above, because move_it_in_display_line_to calls
18296 handle_line_prefix itself. */
18297 handle_line_prefix (it
);
18300 /* Get the initial row height. This is either the height of the
18301 text hscrolled, if there is any, or zero. */
18302 row
->ascent
= it
->max_ascent
;
18303 row
->height
= it
->max_ascent
+ it
->max_descent
;
18304 row
->phys_ascent
= it
->max_phys_ascent
;
18305 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
18306 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
18308 /* Utility macro to record max and min buffer positions seen until now. */
18309 #define RECORD_MAX_MIN_POS(IT) \
18312 if (IT_CHARPOS (*(IT)) < min_pos) \
18314 min_pos = IT_CHARPOS (*(IT)); \
18315 min_bpos = IT_BYTEPOS (*(IT)); \
18317 if (IT_CHARPOS (*(IT)) > max_pos) \
18319 max_pos = IT_CHARPOS (*(IT)); \
18320 max_bpos = IT_BYTEPOS (*(IT)); \
18325 /* Loop generating characters. The loop is left with IT on the next
18326 character to display. */
18329 int n_glyphs_before
, hpos_before
, x_before
;
18331 int ascent
= 0, descent
= 0, phys_ascent
= 0, phys_descent
= 0;
18333 /* Retrieve the next thing to display. Value is zero if end of
18335 if (!get_next_display_element (it
))
18337 /* Maybe add a space at the end of this line that is used to
18338 display the cursor there under X. Set the charpos of the
18339 first glyph of blank lines not corresponding to any text
18341 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
18342 row
->exact_window_width_line_p
= 1;
18343 else if ((append_space_for_newline (it
, 1) && row
->used
[TEXT_AREA
] == 1)
18344 || row
->used
[TEXT_AREA
] == 0)
18346 row
->glyphs
[TEXT_AREA
]->charpos
= -1;
18347 row
->displays_text_p
= 0;
18349 if (!NILP (BVAR (XBUFFER (it
->w
->buffer
), indicate_empty_lines
))
18350 && (!MINI_WINDOW_P (it
->w
)
18351 || (minibuf_level
&& EQ (it
->window
, minibuf_window
))))
18352 row
->indicate_empty_line_p
= 1;
18355 it
->continuation_lines_width
= 0;
18356 row
->ends_at_zv_p
= 1;
18357 /* A row that displays right-to-left text must always have
18358 its last face extended all the way to the end of line,
18359 even if this row ends in ZV, because we still write to
18360 the screen left to right. */
18361 if (row
->reversed_p
)
18362 extend_face_to_end_of_line (it
);
18366 /* Now, get the metrics of what we want to display. This also
18367 generates glyphs in `row' (which is IT->glyph_row). */
18368 n_glyphs_before
= row
->used
[TEXT_AREA
];
18371 /* Remember the line height so far in case the next element doesn't
18372 fit on the line. */
18373 if (it
->line_wrap
!= TRUNCATE
)
18375 ascent
= it
->max_ascent
;
18376 descent
= it
->max_descent
;
18377 phys_ascent
= it
->max_phys_ascent
;
18378 phys_descent
= it
->max_phys_descent
;
18380 if (it
->line_wrap
== WORD_WRAP
&& it
->area
== TEXT_AREA
)
18382 if (IT_DISPLAYING_WHITESPACE (it
))
18386 SAVE_IT (wrap_it
, *it
, wrap_data
);
18388 wrap_row_used
= row
->used
[TEXT_AREA
];
18389 wrap_row_ascent
= row
->ascent
;
18390 wrap_row_height
= row
->height
;
18391 wrap_row_phys_ascent
= row
->phys_ascent
;
18392 wrap_row_phys_height
= row
->phys_height
;
18393 wrap_row_extra_line_spacing
= row
->extra_line_spacing
;
18394 wrap_row_min_pos
= min_pos
;
18395 wrap_row_min_bpos
= min_bpos
;
18396 wrap_row_max_pos
= max_pos
;
18397 wrap_row_max_bpos
= max_bpos
;
18403 PRODUCE_GLYPHS (it
);
18405 /* If this display element was in marginal areas, continue with
18407 if (it
->area
!= TEXT_AREA
)
18409 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
18410 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
18411 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
18412 row
->phys_height
= max (row
->phys_height
,
18413 it
->max_phys_ascent
+ it
->max_phys_descent
);
18414 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
18415 it
->max_extra_line_spacing
);
18416 set_iterator_to_next (it
, 1);
18420 /* Does the display element fit on the line? If we truncate
18421 lines, we should draw past the right edge of the window. If
18422 we don't truncate, we want to stop so that we can display the
18423 continuation glyph before the right margin. If lines are
18424 continued, there are two possible strategies for characters
18425 resulting in more than 1 glyph (e.g. tabs): Display as many
18426 glyphs as possible in this line and leave the rest for the
18427 continuation line, or display the whole element in the next
18428 line. Original redisplay did the former, so we do it also. */
18429 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
18430 hpos_before
= it
->hpos
;
18433 if (/* Not a newline. */
18435 /* Glyphs produced fit entirely in the line. */
18436 && it
->current_x
< it
->last_visible_x
)
18438 it
->hpos
+= nglyphs
;
18439 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
18440 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
18441 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
18442 row
->phys_height
= max (row
->phys_height
,
18443 it
->max_phys_ascent
+ it
->max_phys_descent
);
18444 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
18445 it
->max_extra_line_spacing
);
18446 if (it
->current_x
- it
->pixel_width
< it
->first_visible_x
)
18447 row
->x
= x
- it
->first_visible_x
;
18448 /* Record the maximum and minimum buffer positions seen so
18449 far in glyphs that will be displayed by this row. */
18451 RECORD_MAX_MIN_POS (it
);
18456 struct glyph
*glyph
;
18458 for (i
= 0; i
< nglyphs
; ++i
, x
= new_x
)
18460 glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
18461 new_x
= x
+ glyph
->pixel_width
;
18463 if (/* Lines are continued. */
18464 it
->line_wrap
!= TRUNCATE
18465 && (/* Glyph doesn't fit on the line. */
18466 new_x
> it
->last_visible_x
18467 /* Or it fits exactly on a window system frame. */
18468 || (new_x
== it
->last_visible_x
18469 && FRAME_WINDOW_P (it
->f
))))
18471 /* End of a continued line. */
18474 || (new_x
== it
->last_visible_x
18475 && FRAME_WINDOW_P (it
->f
)))
18477 /* Current glyph is the only one on the line or
18478 fits exactly on the line. We must continue
18479 the line because we can't draw the cursor
18480 after the glyph. */
18481 row
->continued_p
= 1;
18482 it
->current_x
= new_x
;
18483 it
->continuation_lines_width
+= new_x
;
18485 /* Record the maximum and minimum buffer
18486 positions seen so far in glyphs that will be
18487 displayed by this row. */
18489 RECORD_MAX_MIN_POS (it
);
18490 if (i
== nglyphs
- 1)
18492 /* If line-wrap is on, check if a previous
18493 wrap point was found. */
18494 if (wrap_row_used
> 0
18495 /* Even if there is a previous wrap
18496 point, continue the line here as
18497 usual, if (i) the previous character
18498 was a space or tab AND (ii) the
18499 current character is not. */
18501 || IT_DISPLAYING_WHITESPACE (it
)))
18504 set_iterator_to_next (it
, 1);
18505 if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
18507 if (!get_next_display_element (it
))
18509 row
->exact_window_width_line_p
= 1;
18510 it
->continuation_lines_width
= 0;
18511 row
->continued_p
= 0;
18512 row
->ends_at_zv_p
= 1;
18514 else if (ITERATOR_AT_END_OF_LINE_P (it
))
18516 row
->continued_p
= 0;
18517 row
->exact_window_width_line_p
= 1;
18522 else if (CHAR_GLYPH_PADDING_P (*glyph
)
18523 && !FRAME_WINDOW_P (it
->f
))
18525 /* A padding glyph that doesn't fit on this line.
18526 This means the whole character doesn't fit
18528 if (row
->reversed_p
)
18529 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
18530 - n_glyphs_before
);
18531 row
->used
[TEXT_AREA
] = n_glyphs_before
;
18533 /* Fill the rest of the row with continuation
18534 glyphs like in 20.x. */
18535 while (row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
]
18536 < row
->glyphs
[1 + TEXT_AREA
])
18537 produce_special_glyphs (it
, IT_CONTINUATION
);
18539 row
->continued_p
= 1;
18540 it
->current_x
= x_before
;
18541 it
->continuation_lines_width
+= x_before
;
18543 /* Restore the height to what it was before the
18544 element not fitting on the line. */
18545 it
->max_ascent
= ascent
;
18546 it
->max_descent
= descent
;
18547 it
->max_phys_ascent
= phys_ascent
;
18548 it
->max_phys_descent
= phys_descent
;
18550 else if (wrap_row_used
> 0)
18553 if (row
->reversed_p
)
18554 unproduce_glyphs (it
,
18555 row
->used
[TEXT_AREA
] - wrap_row_used
);
18556 RESTORE_IT (it
, &wrap_it
, wrap_data
);
18557 it
->continuation_lines_width
+= wrap_x
;
18558 row
->used
[TEXT_AREA
] = wrap_row_used
;
18559 row
->ascent
= wrap_row_ascent
;
18560 row
->height
= wrap_row_height
;
18561 row
->phys_ascent
= wrap_row_phys_ascent
;
18562 row
->phys_height
= wrap_row_phys_height
;
18563 row
->extra_line_spacing
= wrap_row_extra_line_spacing
;
18564 min_pos
= wrap_row_min_pos
;
18565 min_bpos
= wrap_row_min_bpos
;
18566 max_pos
= wrap_row_max_pos
;
18567 max_bpos
= wrap_row_max_bpos
;
18568 row
->continued_p
= 1;
18569 row
->ends_at_zv_p
= 0;
18570 row
->exact_window_width_line_p
= 0;
18571 it
->continuation_lines_width
+= x
;
18573 /* Make sure that a non-default face is extended
18574 up to the right margin of the window. */
18575 extend_face_to_end_of_line (it
);
18577 else if (it
->c
== '\t' && FRAME_WINDOW_P (it
->f
))
18579 /* A TAB that extends past the right edge of the
18580 window. This produces a single glyph on
18581 window system frames. We leave the glyph in
18582 this row and let it fill the row, but don't
18583 consume the TAB. */
18584 it
->continuation_lines_width
+= it
->last_visible_x
;
18585 row
->ends_in_middle_of_char_p
= 1;
18586 row
->continued_p
= 1;
18587 glyph
->pixel_width
= it
->last_visible_x
- x
;
18588 it
->starts_in_middle_of_char_p
= 1;
18592 /* Something other than a TAB that draws past
18593 the right edge of the window. Restore
18594 positions to values before the element. */
18595 if (row
->reversed_p
)
18596 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
18597 - (n_glyphs_before
+ i
));
18598 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
18600 /* Display continuation glyphs. */
18601 if (!FRAME_WINDOW_P (it
->f
))
18602 produce_special_glyphs (it
, IT_CONTINUATION
);
18603 row
->continued_p
= 1;
18605 it
->current_x
= x_before
;
18606 it
->continuation_lines_width
+= x
;
18607 extend_face_to_end_of_line (it
);
18609 if (nglyphs
> 1 && i
> 0)
18611 row
->ends_in_middle_of_char_p
= 1;
18612 it
->starts_in_middle_of_char_p
= 1;
18615 /* Restore the height to what it was before the
18616 element not fitting on the line. */
18617 it
->max_ascent
= ascent
;
18618 it
->max_descent
= descent
;
18619 it
->max_phys_ascent
= phys_ascent
;
18620 it
->max_phys_descent
= phys_descent
;
18625 else if (new_x
> it
->first_visible_x
)
18627 /* Increment number of glyphs actually displayed. */
18630 /* Record the maximum and minimum buffer positions
18631 seen so far in glyphs that will be displayed by
18634 RECORD_MAX_MIN_POS (it
);
18636 if (x
< it
->first_visible_x
)
18637 /* Glyph is partially visible, i.e. row starts at
18638 negative X position. */
18639 row
->x
= x
- it
->first_visible_x
;
18643 /* Glyph is completely off the left margin of the
18644 window. This should not happen because of the
18645 move_it_in_display_line at the start of this
18646 function, unless the text display area of the
18647 window is empty. */
18648 xassert (it
->first_visible_x
<= it
->last_visible_x
);
18652 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
18653 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
18654 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
18655 row
->phys_height
= max (row
->phys_height
,
18656 it
->max_phys_ascent
+ it
->max_phys_descent
);
18657 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
18658 it
->max_extra_line_spacing
);
18660 /* End of this display line if row is continued. */
18661 if (row
->continued_p
|| row
->ends_at_zv_p
)
18666 /* Is this a line end? If yes, we're also done, after making
18667 sure that a non-default face is extended up to the right
18668 margin of the window. */
18669 if (ITERATOR_AT_END_OF_LINE_P (it
))
18671 int used_before
= row
->used
[TEXT_AREA
];
18673 row
->ends_in_newline_from_string_p
= STRINGP (it
->object
);
18675 /* Add a space at the end of the line that is used to
18676 display the cursor there. */
18677 if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
18678 append_space_for_newline (it
, 0);
18680 /* Extend the face to the end of the line. */
18681 extend_face_to_end_of_line (it
);
18683 /* Make sure we have the position. */
18684 if (used_before
== 0)
18685 row
->glyphs
[TEXT_AREA
]->charpos
= CHARPOS (it
->position
);
18687 /* Record the position of the newline, for use in
18689 it
->eol_pos
= it
->current
.pos
;
18691 /* Consume the line end. This skips over invisible lines. */
18692 set_iterator_to_next (it
, 1);
18693 it
->continuation_lines_width
= 0;
18697 /* Proceed with next display element. Note that this skips
18698 over lines invisible because of selective display. */
18699 set_iterator_to_next (it
, 1);
18701 /* If we truncate lines, we are done when the last displayed
18702 glyphs reach past the right margin of the window. */
18703 if (it
->line_wrap
== TRUNCATE
18704 && (FRAME_WINDOW_P (it
->f
)
18705 ? (it
->current_x
>= it
->last_visible_x
)
18706 : (it
->current_x
> it
->last_visible_x
)))
18708 /* Maybe add truncation glyphs. */
18709 if (!FRAME_WINDOW_P (it
->f
))
18713 if (!row
->reversed_p
)
18715 for (i
= row
->used
[TEXT_AREA
] - 1; i
> 0; --i
)
18716 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
18721 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
18722 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][i
]))
18724 /* Remove any padding glyphs at the front of ROW, to
18725 make room for the truncation glyphs we will be
18726 adding below. The loop below always inserts at
18727 least one truncation glyph, so also remove the
18728 last glyph added to ROW. */
18729 unproduce_glyphs (it
, i
+ 1);
18730 /* Adjust i for the loop below. */
18731 i
= row
->used
[TEXT_AREA
] - (i
+ 1);
18734 for (n
= row
->used
[TEXT_AREA
]; i
< n
; ++i
)
18736 row
->used
[TEXT_AREA
] = i
;
18737 produce_special_glyphs (it
, IT_TRUNCATION
);
18740 else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it
))
18742 /* Don't truncate if we can overflow newline into fringe. */
18743 if (!get_next_display_element (it
))
18745 it
->continuation_lines_width
= 0;
18746 row
->ends_at_zv_p
= 1;
18747 row
->exact_window_width_line_p
= 1;
18750 if (ITERATOR_AT_END_OF_LINE_P (it
))
18752 row
->exact_window_width_line_p
= 1;
18753 goto at_end_of_line
;
18757 row
->truncated_on_right_p
= 1;
18758 it
->continuation_lines_width
= 0;
18759 reseat_at_next_visible_line_start (it
, 0);
18760 row
->ends_at_zv_p
= FETCH_BYTE (IT_BYTEPOS (*it
) - 1) != '\n';
18761 it
->hpos
= hpos_before
;
18762 it
->current_x
= x_before
;
18767 /* If line is not empty and hscrolled, maybe insert truncation glyphs
18768 at the left window margin. */
18769 if (it
->first_visible_x
18770 && IT_CHARPOS (*it
) != CHARPOS (row
->start
.pos
))
18772 if (!FRAME_WINDOW_P (it
->f
))
18773 insert_left_trunc_glyphs (it
);
18774 row
->truncated_on_left_p
= 1;
18777 /* Remember the position at which this line ends.
18779 BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
18780 cannot be before the call to find_row_edges below, since that is
18781 where these positions are determined. */
18782 row
->end
= it
->current
;
18785 row
->minpos
= row
->start
.pos
;
18786 row
->maxpos
= row
->end
.pos
;
18790 /* ROW->minpos and ROW->maxpos must be the smallest and
18791 `1 + the largest' buffer positions in ROW. But if ROW was
18792 bidi-reordered, these two positions can be anywhere in the
18793 row, so we must determine them now. */
18794 find_row_edges (it
, row
, min_pos
, min_bpos
, max_pos
, max_bpos
);
18797 /* If the start of this line is the overlay arrow-position, then
18798 mark this glyph row as the one containing the overlay arrow.
18799 This is clearly a mess with variable size fonts. It would be
18800 better to let it be displayed like cursors under X. */
18801 if ((row
->displays_text_p
|| !overlay_arrow_seen
)
18802 && (overlay_arrow_string
= overlay_arrow_at_row (it
, row
),
18803 !NILP (overlay_arrow_string
)))
18805 /* Overlay arrow in window redisplay is a fringe bitmap. */
18806 if (STRINGP (overlay_arrow_string
))
18808 struct glyph_row
*arrow_row
18809 = get_overlay_arrow_glyph_row (it
->w
, overlay_arrow_string
);
18810 struct glyph
*glyph
= arrow_row
->glyphs
[TEXT_AREA
];
18811 struct glyph
*arrow_end
= glyph
+ arrow_row
->used
[TEXT_AREA
];
18812 struct glyph
*p
= row
->glyphs
[TEXT_AREA
];
18813 struct glyph
*p2
, *end
;
18815 /* Copy the arrow glyphs. */
18816 while (glyph
< arrow_end
)
18819 /* Throw away padding glyphs. */
18821 end
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
];
18822 while (p2
< end
&& CHAR_GLYPH_PADDING_P (*p2
))
18828 row
->used
[TEXT_AREA
] = p2
- row
->glyphs
[TEXT_AREA
];
18833 xassert (INTEGERP (overlay_arrow_string
));
18834 row
->overlay_arrow_bitmap
= XINT (overlay_arrow_string
);
18836 overlay_arrow_seen
= 1;
18839 /* Compute pixel dimensions of this line. */
18840 compute_line_metrics (it
);
18842 /* Record whether this row ends inside an ellipsis. */
18843 row
->ends_in_ellipsis_p
18844 = (it
->method
== GET_FROM_DISPLAY_VECTOR
18845 && it
->ellipsis_p
);
18847 /* Save fringe bitmaps in this row. */
18848 row
->left_user_fringe_bitmap
= it
->left_user_fringe_bitmap
;
18849 row
->left_user_fringe_face_id
= it
->left_user_fringe_face_id
;
18850 row
->right_user_fringe_bitmap
= it
->right_user_fringe_bitmap
;
18851 row
->right_user_fringe_face_id
= it
->right_user_fringe_face_id
;
18853 it
->left_user_fringe_bitmap
= 0;
18854 it
->left_user_fringe_face_id
= 0;
18855 it
->right_user_fringe_bitmap
= 0;
18856 it
->right_user_fringe_face_id
= 0;
18858 /* Maybe set the cursor. */
18859 cvpos
= it
->w
->cursor
.vpos
;
18861 /* In bidi-reordered rows, keep checking for proper cursor
18862 position even if one has been found already, because buffer
18863 positions in such rows change non-linearly with ROW->VPOS,
18864 when a line is continued. One exception: when we are at ZV,
18865 display cursor on the first suitable glyph row, since all
18866 the empty rows after that also have their position set to ZV. */
18867 /* FIXME: Revisit this when glyph ``spilling'' in continuation
18868 lines' rows is implemented for bidi-reordered rows. */
18870 && !MATRIX_ROW (it
->w
->desired_matrix
, cvpos
)->ends_at_zv_p
))
18871 && PT
>= MATRIX_ROW_START_CHARPOS (row
)
18872 && PT
<= MATRIX_ROW_END_CHARPOS (row
)
18873 && cursor_row_p (row
))
18874 set_cursor_from_row (it
->w
, row
, it
->w
->desired_matrix
, 0, 0, 0, 0);
18876 /* Highlight trailing whitespace. */
18877 if (!NILP (Vshow_trailing_whitespace
))
18878 highlight_trailing_whitespace (it
->f
, it
->glyph_row
);
18880 /* Prepare for the next line. This line starts horizontally at (X
18881 HPOS) = (0 0). Vertical positions are incremented. As a
18882 convenience for the caller, IT->glyph_row is set to the next
18884 it
->current_x
= it
->hpos
= 0;
18885 it
->current_y
+= row
->height
;
18886 SET_TEXT_POS (it
->eol_pos
, 0, 0);
18889 /* The next row should by default use the same value of the
18890 reversed_p flag as this one. set_iterator_to_next decides when
18891 it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
18892 the flag accordingly. */
18893 if (it
->glyph_row
< MATRIX_BOTTOM_TEXT_ROW (it
->w
->desired_matrix
, it
->w
))
18894 it
->glyph_row
->reversed_p
= row
->reversed_p
;
18895 it
->start
= row
->end
;
18896 return row
->displays_text_p
;
18898 #undef RECORD_MAX_MIN_POS
18901 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction
,
18902 Scurrent_bidi_paragraph_direction
, 0, 1, 0,
18903 doc
: /* Return paragraph direction at point in BUFFER.
18904 Value is either `left-to-right' or `right-to-left'.
18905 If BUFFER is omitted or nil, it defaults to the current buffer.
18907 Paragraph direction determines how the text in the paragraph is displayed.
18908 In left-to-right paragraphs, text begins at the left margin of the window
18909 and the reading direction is generally left to right. In right-to-left
18910 paragraphs, text begins at the right margin and is read from right to left.
18912 See also `bidi-paragraph-direction'. */)
18913 (Lisp_Object buffer
)
18915 struct buffer
*buf
= current_buffer
;
18916 struct buffer
*old
= buf
;
18918 if (! NILP (buffer
))
18920 CHECK_BUFFER (buffer
);
18921 buf
= XBUFFER (buffer
);
18924 if (NILP (BVAR (buf
, bidi_display_reordering
)))
18925 return Qleft_to_right
;
18926 else if (!NILP (BVAR (buf
, bidi_paragraph_direction
)))
18927 return BVAR (buf
, bidi_paragraph_direction
);
18930 /* Determine the direction from buffer text. We could try to
18931 use current_matrix if it is up to date, but this seems fast
18932 enough as it is. */
18933 struct bidi_it itb
;
18934 EMACS_INT pos
= BUF_PT (buf
);
18935 EMACS_INT bytepos
= BUF_PT_BYTE (buf
);
18938 set_buffer_temp (buf
);
18939 /* bidi_paragraph_init finds the base direction of the paragraph
18940 by searching forward from paragraph start. We need the base
18941 direction of the current or _previous_ paragraph, so we need
18942 to make sure we are within that paragraph. To that end, find
18943 the previous non-empty line. */
18944 if (pos
>= ZV
&& pos
> BEGV
)
18947 bytepos
= CHAR_TO_BYTE (pos
);
18949 while ((c
= FETCH_BYTE (bytepos
)) == '\n'
18950 || c
== ' ' || c
== '\t' || c
== '\f')
18952 if (bytepos
<= BEGV_BYTE
)
18957 while (!CHAR_HEAD_P (FETCH_BYTE (bytepos
)))
18960 itb
.bytepos
= bytepos
;
18962 itb
.string
.s
= NULL
;
18963 itb
.string
.lstring
= Qnil
;
18964 itb
.frame_window_p
= FRAME_WINDOW_P (SELECTED_FRAME ()); /* guesswork */
18966 itb
.separator_limit
= -1;
18967 itb
.paragraph_dir
= NEUTRAL_DIR
;
18969 bidi_paragraph_init (NEUTRAL_DIR
, &itb
, 1);
18970 set_buffer_temp (old
);
18971 switch (itb
.paragraph_dir
)
18974 return Qleft_to_right
;
18977 return Qright_to_left
;
18987 /***********************************************************************
18989 ***********************************************************************/
18991 /* Redisplay the menu bar in the frame for window W.
18993 The menu bar of X frames that don't have X toolkit support is
18994 displayed in a special window W->frame->menu_bar_window.
18996 The menu bar of terminal frames is treated specially as far as
18997 glyph matrices are concerned. Menu bar lines are not part of
18998 windows, so the update is done directly on the frame matrix rows
18999 for the menu bar. */
19002 display_menu_bar (struct window
*w
)
19004 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
19009 /* Don't do all this for graphical frames. */
19011 if (FRAME_W32_P (f
))
19014 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
19020 if (FRAME_NS_P (f
))
19022 #endif /* HAVE_NS */
19024 #ifdef USE_X_TOOLKIT
19025 xassert (!FRAME_WINDOW_P (f
));
19026 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
, MENU_FACE_ID
);
19027 it
.first_visible_x
= 0;
19028 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
19029 #else /* not USE_X_TOOLKIT */
19030 if (FRAME_WINDOW_P (f
))
19032 /* Menu bar lines are displayed in the desired matrix of the
19033 dummy window menu_bar_window. */
19034 struct window
*menu_w
;
19035 xassert (WINDOWP (f
->menu_bar_window
));
19036 menu_w
= XWINDOW (f
->menu_bar_window
);
19037 init_iterator (&it
, menu_w
, -1, -1, menu_w
->desired_matrix
->rows
,
19039 it
.first_visible_x
= 0;
19040 it
.last_visible_x
= FRAME_TOTAL_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
19044 /* This is a TTY frame, i.e. character hpos/vpos are used as
19046 init_iterator (&it
, w
, -1, -1, f
->desired_matrix
->rows
,
19048 it
.first_visible_x
= 0;
19049 it
.last_visible_x
= FRAME_COLS (f
);
19051 #endif /* not USE_X_TOOLKIT */
19053 /* FIXME: This should be controlled by a user option. See the
19054 comments in redisplay_tool_bar and display_mode_line about
19056 it
.paragraph_embedding
= L2R
;
19058 if (! mode_line_inverse_video
)
19059 /* Force the menu-bar to be displayed in the default face. */
19060 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
19062 /* Clear all rows of the menu bar. */
19063 for (i
= 0; i
< FRAME_MENU_BAR_LINES (f
); ++i
)
19065 struct glyph_row
*row
= it
.glyph_row
+ i
;
19066 clear_glyph_row (row
);
19067 row
->enabled_p
= 1;
19068 row
->full_width_p
= 1;
19071 /* Display all items of the menu bar. */
19072 items
= FRAME_MENU_BAR_ITEMS (it
.f
);
19073 for (i
= 0; i
< ASIZE (items
); i
+= 4)
19075 Lisp_Object string
;
19077 /* Stop at nil string. */
19078 string
= AREF (items
, i
+ 1);
19082 /* Remember where item was displayed. */
19083 ASET (items
, i
+ 3, make_number (it
.hpos
));
19085 /* Display the item, pad with one space. */
19086 if (it
.current_x
< it
.last_visible_x
)
19087 display_string (NULL
, string
, Qnil
, 0, 0, &it
,
19088 SCHARS (string
) + 1, 0, 0, -1);
19091 /* Fill out the line with spaces. */
19092 if (it
.current_x
< it
.last_visible_x
)
19093 display_string ("", Qnil
, Qnil
, 0, 0, &it
, -1, 0, 0, -1);
19095 /* Compute the total height of the lines. */
19096 compute_line_metrics (&it
);
19101 /***********************************************************************
19103 ***********************************************************************/
19105 /* Redisplay mode lines in the window tree whose root is WINDOW. If
19106 FORCE is non-zero, redisplay mode lines unconditionally.
19107 Otherwise, redisplay only mode lines that are garbaged. Value is
19108 the number of windows whose mode lines were redisplayed. */
19111 redisplay_mode_lines (Lisp_Object window
, int force
)
19115 while (!NILP (window
))
19117 struct window
*w
= XWINDOW (window
);
19119 if (WINDOWP (w
->hchild
))
19120 nwindows
+= redisplay_mode_lines (w
->hchild
, force
);
19121 else if (WINDOWP (w
->vchild
))
19122 nwindows
+= redisplay_mode_lines (w
->vchild
, force
);
19124 || FRAME_GARBAGED_P (XFRAME (w
->frame
))
19125 || !MATRIX_MODE_LINE_ROW (w
->current_matrix
)->enabled_p
)
19127 struct text_pos lpoint
;
19128 struct buffer
*old
= current_buffer
;
19130 /* Set the window's buffer for the mode line display. */
19131 SET_TEXT_POS (lpoint
, PT
, PT_BYTE
);
19132 set_buffer_internal_1 (XBUFFER (w
->buffer
));
19134 /* Point refers normally to the selected window. For any
19135 other window, set up appropriate value. */
19136 if (!EQ (window
, selected_window
))
19138 struct text_pos pt
;
19140 SET_TEXT_POS_FROM_MARKER (pt
, w
->pointm
);
19141 if (CHARPOS (pt
) < BEGV
)
19142 TEMP_SET_PT_BOTH (BEGV
, BEGV_BYTE
);
19143 else if (CHARPOS (pt
) > (ZV
- 1))
19144 TEMP_SET_PT_BOTH (ZV
, ZV_BYTE
);
19146 TEMP_SET_PT_BOTH (CHARPOS (pt
), BYTEPOS (pt
));
19149 /* Display mode lines. */
19150 clear_glyph_matrix (w
->desired_matrix
);
19151 if (display_mode_lines (w
))
19154 w
->must_be_updated_p
= 1;
19157 /* Restore old settings. */
19158 set_buffer_internal_1 (old
);
19159 TEMP_SET_PT_BOTH (CHARPOS (lpoint
), BYTEPOS (lpoint
));
19169 /* Display the mode and/or header line of window W. Value is the
19170 sum number of mode lines and header lines displayed. */
19173 display_mode_lines (struct window
*w
)
19175 Lisp_Object old_selected_window
, old_selected_frame
;
19178 old_selected_frame
= selected_frame
;
19179 selected_frame
= w
->frame
;
19180 old_selected_window
= selected_window
;
19181 XSETWINDOW (selected_window
, w
);
19183 /* These will be set while the mode line specs are processed. */
19184 line_number_displayed
= 0;
19185 w
->column_number_displayed
= Qnil
;
19187 if (WINDOW_WANTS_MODELINE_P (w
))
19189 struct window
*sel_w
= XWINDOW (old_selected_window
);
19191 /* Select mode line face based on the real selected window. */
19192 display_mode_line (w
, CURRENT_MODE_LINE_FACE_ID_3 (sel_w
, sel_w
, w
),
19193 BVAR (current_buffer
, mode_line_format
));
19197 if (WINDOW_WANTS_HEADER_LINE_P (w
))
19199 display_mode_line (w
, HEADER_LINE_FACE_ID
,
19200 BVAR (current_buffer
, header_line_format
));
19204 selected_frame
= old_selected_frame
;
19205 selected_window
= old_selected_window
;
19210 /* Display mode or header line of window W. FACE_ID specifies which
19211 line to display; it is either MODE_LINE_FACE_ID or
19212 HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
19213 display. Value is the pixel height of the mode/header line
19217 display_mode_line (struct window
*w
, enum face_id face_id
, Lisp_Object format
)
19221 int count
= SPECPDL_INDEX ();
19223 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
19224 /* Don't extend on a previously drawn mode-line.
19225 This may happen if called from pos_visible_p. */
19226 it
.glyph_row
->enabled_p
= 0;
19227 prepare_desired_row (it
.glyph_row
);
19229 it
.glyph_row
->mode_line_p
= 1;
19231 if (! mode_line_inverse_video
)
19232 /* Force the mode-line to be displayed in the default face. */
19233 it
.base_face_id
= it
.face_id
= DEFAULT_FACE_ID
;
19235 /* FIXME: This should be controlled by a user option. But
19236 supporting such an option is not trivial, since the mode line is
19237 made up of many separate strings. */
19238 it
.paragraph_embedding
= L2R
;
19240 record_unwind_protect (unwind_format_mode_line
,
19241 format_mode_line_unwind_data (NULL
, Qnil
, 0));
19243 mode_line_target
= MODE_LINE_DISPLAY
;
19245 /* Temporarily make frame's keyboard the current kboard so that
19246 kboard-local variables in the mode_line_format will get the right
19248 push_kboard (FRAME_KBOARD (it
.f
));
19249 record_unwind_save_match_data ();
19250 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
19253 unbind_to (count
, Qnil
);
19255 /* Fill up with spaces. */
19256 display_string (" ", Qnil
, Qnil
, 0, 0, &it
, 10000, -1, -1, 0);
19258 compute_line_metrics (&it
);
19259 it
.glyph_row
->full_width_p
= 1;
19260 it
.glyph_row
->continued_p
= 0;
19261 it
.glyph_row
->truncated_on_left_p
= 0;
19262 it
.glyph_row
->truncated_on_right_p
= 0;
19264 /* Make a 3D mode-line have a shadow at its right end. */
19265 face
= FACE_FROM_ID (it
.f
, face_id
);
19266 extend_face_to_end_of_line (&it
);
19267 if (face
->box
!= FACE_NO_BOX
)
19269 struct glyph
*last
= (it
.glyph_row
->glyphs
[TEXT_AREA
]
19270 + it
.glyph_row
->used
[TEXT_AREA
] - 1);
19271 last
->right_box_line_p
= 1;
19274 return it
.glyph_row
->height
;
19277 /* Move element ELT in LIST to the front of LIST.
19278 Return the updated list. */
19281 move_elt_to_front (Lisp_Object elt
, Lisp_Object list
)
19283 register Lisp_Object tail
, prev
;
19284 register Lisp_Object tem
;
19288 while (CONSP (tail
))
19294 /* Splice out the link TAIL. */
19296 list
= XCDR (tail
);
19298 Fsetcdr (prev
, XCDR (tail
));
19300 /* Now make it the first. */
19301 Fsetcdr (tail
, list
);
19306 tail
= XCDR (tail
);
19310 /* Not found--return unchanged LIST. */
19314 /* Contribute ELT to the mode line for window IT->w. How it
19315 translates into text depends on its data type.
19317 IT describes the display environment in which we display, as usual.
19319 DEPTH is the depth in recursion. It is used to prevent
19320 infinite recursion here.
19322 FIELD_WIDTH is the number of characters the display of ELT should
19323 occupy in the mode line, and PRECISION is the maximum number of
19324 characters to display from ELT's representation. See
19325 display_string for details.
19327 Returns the hpos of the end of the text generated by ELT.
19329 PROPS is a property list to add to any string we encounter.
19331 If RISKY is nonzero, remove (disregard) any properties in any string
19332 we encounter, and ignore :eval and :propertize.
19334 The global variable `mode_line_target' determines whether the
19335 output is passed to `store_mode_line_noprop',
19336 `store_mode_line_string', or `display_string'. */
19339 display_mode_element (struct it
*it
, int depth
, int field_width
, int precision
,
19340 Lisp_Object elt
, Lisp_Object props
, int risky
)
19342 int n
= 0, field
, prec
;
19347 elt
= build_string ("*too-deep*");
19351 switch (SWITCH_ENUM_CAST (XTYPE (elt
)))
19355 /* A string: output it and check for %-constructs within it. */
19357 EMACS_INT offset
= 0;
19359 if (SCHARS (elt
) > 0
19360 && (!NILP (props
) || risky
))
19362 Lisp_Object oprops
, aelt
;
19363 oprops
= Ftext_properties_at (make_number (0), elt
);
19365 /* If the starting string's properties are not what
19366 we want, translate the string. Also, if the string
19367 is risky, do that anyway. */
19369 if (NILP (Fequal (props
, oprops
)) || risky
)
19371 /* If the starting string has properties,
19372 merge the specified ones onto the existing ones. */
19373 if (! NILP (oprops
) && !risky
)
19377 oprops
= Fcopy_sequence (oprops
);
19379 while (CONSP (tem
))
19381 oprops
= Fplist_put (oprops
, XCAR (tem
),
19382 XCAR (XCDR (tem
)));
19383 tem
= XCDR (XCDR (tem
));
19388 aelt
= Fassoc (elt
, mode_line_proptrans_alist
);
19389 if (! NILP (aelt
) && !NILP (Fequal (props
, XCDR (aelt
))))
19391 /* AELT is what we want. Move it to the front
19392 without consing. */
19394 mode_line_proptrans_alist
19395 = move_elt_to_front (aelt
, mode_line_proptrans_alist
);
19401 /* If AELT has the wrong props, it is useless.
19402 so get rid of it. */
19404 mode_line_proptrans_alist
19405 = Fdelq (aelt
, mode_line_proptrans_alist
);
19407 elt
= Fcopy_sequence (elt
);
19408 Fset_text_properties (make_number (0), Flength (elt
),
19410 /* Add this item to mode_line_proptrans_alist. */
19411 mode_line_proptrans_alist
19412 = Fcons (Fcons (elt
, props
),
19413 mode_line_proptrans_alist
);
19414 /* Truncate mode_line_proptrans_alist
19415 to at most 50 elements. */
19416 tem
= Fnthcdr (make_number (50),
19417 mode_line_proptrans_alist
);
19419 XSETCDR (tem
, Qnil
);
19428 prec
= precision
- n
;
19429 switch (mode_line_target
)
19431 case MODE_LINE_NOPROP
:
19432 case MODE_LINE_TITLE
:
19433 n
+= store_mode_line_noprop (SSDATA (elt
), -1, prec
);
19435 case MODE_LINE_STRING
:
19436 n
+= store_mode_line_string (NULL
, elt
, 1, 0, prec
, Qnil
);
19438 case MODE_LINE_DISPLAY
:
19439 n
+= display_string (NULL
, elt
, Qnil
, 0, 0, it
,
19440 0, prec
, 0, STRING_MULTIBYTE (elt
));
19447 /* Handle the non-literal case. */
19449 while ((precision
<= 0 || n
< precision
)
19450 && SREF (elt
, offset
) != 0
19451 && (mode_line_target
!= MODE_LINE_DISPLAY
19452 || it
->current_x
< it
->last_visible_x
))
19454 EMACS_INT last_offset
= offset
;
19456 /* Advance to end of string or next format specifier. */
19457 while ((c
= SREF (elt
, offset
++)) != '\0' && c
!= '%')
19460 if (offset
- 1 != last_offset
)
19462 EMACS_INT nchars
, nbytes
;
19464 /* Output to end of string or up to '%'. Field width
19465 is length of string. Don't output more than
19466 PRECISION allows us. */
19469 prec
= c_string_width (SDATA (elt
) + last_offset
,
19470 offset
- last_offset
, precision
- n
,
19473 switch (mode_line_target
)
19475 case MODE_LINE_NOPROP
:
19476 case MODE_LINE_TITLE
:
19477 n
+= store_mode_line_noprop (SSDATA (elt
) + last_offset
, 0, prec
);
19479 case MODE_LINE_STRING
:
19481 EMACS_INT bytepos
= last_offset
;
19482 EMACS_INT charpos
= string_byte_to_char (elt
, bytepos
);
19483 EMACS_INT endpos
= (precision
<= 0
19484 ? string_byte_to_char (elt
, offset
)
19485 : charpos
+ nchars
);
19487 n
+= store_mode_line_string (NULL
,
19488 Fsubstring (elt
, make_number (charpos
),
19489 make_number (endpos
)),
19493 case MODE_LINE_DISPLAY
:
19495 EMACS_INT bytepos
= last_offset
;
19496 EMACS_INT charpos
= string_byte_to_char (elt
, bytepos
);
19498 if (precision
<= 0)
19499 nchars
= string_byte_to_char (elt
, offset
) - charpos
;
19500 n
+= display_string (NULL
, elt
, Qnil
, 0, charpos
,
19502 STRING_MULTIBYTE (elt
));
19507 else /* c == '%' */
19509 EMACS_INT percent_position
= offset
;
19511 /* Get the specified minimum width. Zero means
19514 while ((c
= SREF (elt
, offset
++)) >= '0' && c
<= '9')
19515 field
= field
* 10 + c
- '0';
19517 /* Don't pad beyond the total padding allowed. */
19518 if (field_width
- n
> 0 && field
> field_width
- n
)
19519 field
= field_width
- n
;
19521 /* Note that either PRECISION <= 0 or N < PRECISION. */
19522 prec
= precision
- n
;
19525 n
+= display_mode_element (it
, depth
, field
, prec
,
19526 Vglobal_mode_string
, props
,
19531 EMACS_INT bytepos
, charpos
;
19533 Lisp_Object string
;
19535 bytepos
= percent_position
;
19536 charpos
= (STRING_MULTIBYTE (elt
)
19537 ? string_byte_to_char (elt
, bytepos
)
19539 spec
= decode_mode_spec (it
->w
, c
, field
, &string
);
19540 multibyte
= STRINGP (string
) && STRING_MULTIBYTE (string
);
19542 switch (mode_line_target
)
19544 case MODE_LINE_NOPROP
:
19545 case MODE_LINE_TITLE
:
19546 n
+= store_mode_line_noprop (spec
, field
, prec
);
19548 case MODE_LINE_STRING
:
19550 int len
= strlen (spec
);
19551 Lisp_Object tem
= make_string (spec
, len
);
19552 props
= Ftext_properties_at (make_number (charpos
), elt
);
19553 /* Should only keep face property in props */
19554 n
+= store_mode_line_string (NULL
, tem
, 0, field
, prec
, props
);
19557 case MODE_LINE_DISPLAY
:
19559 int nglyphs_before
, nwritten
;
19561 nglyphs_before
= it
->glyph_row
->used
[TEXT_AREA
];
19562 nwritten
= display_string (spec
, string
, elt
,
19567 /* Assign to the glyphs written above the
19568 string where the `%x' came from, position
19572 struct glyph
*glyph
19573 = (it
->glyph_row
->glyphs
[TEXT_AREA
]
19577 for (i
= 0; i
< nwritten
; ++i
)
19579 glyph
[i
].object
= elt
;
19580 glyph
[i
].charpos
= charpos
;
19597 /* A symbol: process the value of the symbol recursively
19598 as if it appeared here directly. Avoid error if symbol void.
19599 Special case: if value of symbol is a string, output the string
19602 register Lisp_Object tem
;
19604 /* If the variable is not marked as risky to set
19605 then its contents are risky to use. */
19606 if (NILP (Fget (elt
, Qrisky_local_variable
)))
19609 tem
= Fboundp (elt
);
19612 tem
= Fsymbol_value (elt
);
19613 /* If value is a string, output that string literally:
19614 don't check for % within it. */
19618 if (!EQ (tem
, elt
))
19620 /* Give up right away for nil or t. */
19630 register Lisp_Object car
, tem
;
19632 /* A cons cell: five distinct cases.
19633 If first element is :eval or :propertize, do something special.
19634 If first element is a string or a cons, process all the elements
19635 and effectively concatenate them.
19636 If first element is a negative number, truncate displaying cdr to
19637 at most that many characters. If positive, pad (with spaces)
19638 to at least that many characters.
19639 If first element is a symbol, process the cadr or caddr recursively
19640 according to whether the symbol's value is non-nil or nil. */
19642 if (EQ (car
, QCeval
))
19644 /* An element of the form (:eval FORM) means evaluate FORM
19645 and use the result as mode line elements. */
19650 if (CONSP (XCDR (elt
)))
19653 spec
= safe_eval (XCAR (XCDR (elt
)));
19654 n
+= display_mode_element (it
, depth
, field_width
- n
,
19655 precision
- n
, spec
, props
,
19659 else if (EQ (car
, QCpropertize
))
19661 /* An element of the form (:propertize ELT PROPS...)
19662 means display ELT but applying properties PROPS. */
19667 if (CONSP (XCDR (elt
)))
19668 n
+= display_mode_element (it
, depth
, field_width
- n
,
19669 precision
- n
, XCAR (XCDR (elt
)),
19670 XCDR (XCDR (elt
)), risky
);
19672 else if (SYMBOLP (car
))
19674 tem
= Fboundp (car
);
19678 /* elt is now the cdr, and we know it is a cons cell.
19679 Use its car if CAR has a non-nil value. */
19682 tem
= Fsymbol_value (car
);
19689 /* Symbol's value is nil (or symbol is unbound)
19690 Get the cddr of the original list
19691 and if possible find the caddr and use that. */
19695 else if (!CONSP (elt
))
19700 else if (INTEGERP (car
))
19702 register int lim
= XINT (car
);
19706 /* Negative int means reduce maximum width. */
19707 if (precision
<= 0)
19710 precision
= min (precision
, -lim
);
19714 /* Padding specified. Don't let it be more than
19715 current maximum. */
19717 lim
= min (precision
, lim
);
19719 /* If that's more padding than already wanted, queue it.
19720 But don't reduce padding already specified even if
19721 that is beyond the current truncation point. */
19722 field_width
= max (lim
, field_width
);
19726 else if (STRINGP (car
) || CONSP (car
))
19728 Lisp_Object halftail
= elt
;
19732 && (precision
<= 0 || n
< precision
))
19734 n
+= display_mode_element (it
, depth
,
19735 /* Do padding only after the last
19736 element in the list. */
19737 (! CONSP (XCDR (elt
))
19740 precision
- n
, XCAR (elt
),
19744 if ((len
& 1) == 0)
19745 halftail
= XCDR (halftail
);
19746 /* Check for cycle. */
19747 if (EQ (halftail
, elt
))
19756 elt
= build_string ("*invalid*");
19760 /* Pad to FIELD_WIDTH. */
19761 if (field_width
> 0 && n
< field_width
)
19763 switch (mode_line_target
)
19765 case MODE_LINE_NOPROP
:
19766 case MODE_LINE_TITLE
:
19767 n
+= store_mode_line_noprop ("", field_width
- n
, 0);
19769 case MODE_LINE_STRING
:
19770 n
+= store_mode_line_string ("", Qnil
, 0, field_width
- n
, 0, Qnil
);
19772 case MODE_LINE_DISPLAY
:
19773 n
+= display_string ("", Qnil
, Qnil
, 0, 0, it
, field_width
- n
,
19782 /* Store a mode-line string element in mode_line_string_list.
19784 If STRING is non-null, display that C string. Otherwise, the Lisp
19785 string LISP_STRING is displayed.
19787 FIELD_WIDTH is the minimum number of output glyphs to produce.
19788 If STRING has fewer characters than FIELD_WIDTH, pad to the right
19789 with spaces. FIELD_WIDTH <= 0 means don't pad.
19791 PRECISION is the maximum number of characters to output from
19792 STRING. PRECISION <= 0 means don't truncate the string.
19794 If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
19795 properties to the string.
19797 PROPS are the properties to add to the string.
19798 The mode_line_string_face face property is always added to the string.
19802 store_mode_line_string (const char *string
, Lisp_Object lisp_string
, int copy_string
,
19803 int field_width
, int precision
, Lisp_Object props
)
19808 if (string
!= NULL
)
19810 len
= strlen (string
);
19811 if (precision
> 0 && len
> precision
)
19813 lisp_string
= make_string (string
, len
);
19815 props
= mode_line_string_face_prop
;
19816 else if (!NILP (mode_line_string_face
))
19818 Lisp_Object face
= Fplist_get (props
, Qface
);
19819 props
= Fcopy_sequence (props
);
19821 face
= mode_line_string_face
;
19823 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
19824 props
= Fplist_put (props
, Qface
, face
);
19826 Fadd_text_properties (make_number (0), make_number (len
),
19827 props
, lisp_string
);
19831 len
= XFASTINT (Flength (lisp_string
));
19832 if (precision
> 0 && len
> precision
)
19835 lisp_string
= Fsubstring (lisp_string
, make_number (0), make_number (len
));
19838 if (!NILP (mode_line_string_face
))
19842 props
= Ftext_properties_at (make_number (0), lisp_string
);
19843 face
= Fplist_get (props
, Qface
);
19845 face
= mode_line_string_face
;
19847 face
= Fcons (face
, Fcons (mode_line_string_face
, Qnil
));
19848 props
= Fcons (Qface
, Fcons (face
, Qnil
));
19850 lisp_string
= Fcopy_sequence (lisp_string
);
19853 Fadd_text_properties (make_number (0), make_number (len
),
19854 props
, lisp_string
);
19859 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
19863 if (field_width
> len
)
19865 field_width
-= len
;
19866 lisp_string
= Fmake_string (make_number (field_width
), make_number (' '));
19868 Fadd_text_properties (make_number (0), make_number (field_width
),
19869 props
, lisp_string
);
19870 mode_line_string_list
= Fcons (lisp_string
, mode_line_string_list
);
19878 DEFUN ("format-mode-line", Fformat_mode_line
, Sformat_mode_line
,
19880 doc
: /* Format a string out of a mode line format specification.
19881 First arg FORMAT specifies the mode line format (see `mode-line-format'
19882 for details) to use.
19884 By default, the format is evaluated for the currently selected window.
19886 Optional second arg FACE specifies the face property to put on all
19887 characters for which no face is specified. The value nil means the
19888 default face. The value t means whatever face the window's mode line
19889 currently uses (either `mode-line' or `mode-line-inactive',
19890 depending on whether the window is the selected window or not).
19891 An integer value means the value string has no text
19894 Optional third and fourth args WINDOW and BUFFER specify the window
19895 and buffer to use as the context for the formatting (defaults
19896 are the selected window and the WINDOW's buffer). */)
19897 (Lisp_Object format
, Lisp_Object face
,
19898 Lisp_Object window
, Lisp_Object buffer
)
19903 struct buffer
*old_buffer
= NULL
;
19905 int no_props
= INTEGERP (face
);
19906 int count
= SPECPDL_INDEX ();
19908 int string_start
= 0;
19911 window
= selected_window
;
19912 CHECK_WINDOW (window
);
19913 w
= XWINDOW (window
);
19916 buffer
= w
->buffer
;
19917 CHECK_BUFFER (buffer
);
19919 /* Make formatting the modeline a non-op when noninteractive, otherwise
19920 there will be problems later caused by a partially initialized frame. */
19921 if (NILP (format
) || noninteractive
)
19922 return empty_unibyte_string
;
19927 face_id
= (NILP (face
) || EQ (face
, Qdefault
)) ? DEFAULT_FACE_ID
19928 : EQ (face
, Qt
) ? (EQ (window
, selected_window
)
19929 ? MODE_LINE_FACE_ID
: MODE_LINE_INACTIVE_FACE_ID
)
19930 : EQ (face
, Qmode_line
) ? MODE_LINE_FACE_ID
19931 : EQ (face
, Qmode_line_inactive
) ? MODE_LINE_INACTIVE_FACE_ID
19932 : EQ (face
, Qheader_line
) ? HEADER_LINE_FACE_ID
19933 : EQ (face
, Qtool_bar
) ? TOOL_BAR_FACE_ID
19936 if (XBUFFER (buffer
) != current_buffer
)
19937 old_buffer
= current_buffer
;
19939 /* Save things including mode_line_proptrans_alist,
19940 and set that to nil so that we don't alter the outer value. */
19941 record_unwind_protect (unwind_format_mode_line
,
19942 format_mode_line_unwind_data
19943 (old_buffer
, selected_window
, 1));
19944 mode_line_proptrans_alist
= Qnil
;
19946 Fselect_window (window
, Qt
);
19948 set_buffer_internal_1 (XBUFFER (buffer
));
19950 init_iterator (&it
, w
, -1, -1, NULL
, face_id
);
19954 mode_line_target
= MODE_LINE_NOPROP
;
19955 mode_line_string_face_prop
= Qnil
;
19956 mode_line_string_list
= Qnil
;
19957 string_start
= MODE_LINE_NOPROP_LEN (0);
19961 mode_line_target
= MODE_LINE_STRING
;
19962 mode_line_string_list
= Qnil
;
19963 mode_line_string_face
= face
;
19964 mode_line_string_face_prop
19965 = (NILP (face
) ? Qnil
: Fcons (Qface
, Fcons (face
, Qnil
)));
19968 push_kboard (FRAME_KBOARD (it
.f
));
19969 display_mode_element (&it
, 0, 0, 0, format
, Qnil
, 0);
19974 len
= MODE_LINE_NOPROP_LEN (string_start
);
19975 str
= make_string (mode_line_noprop_buf
+ string_start
, len
);
19979 mode_line_string_list
= Fnreverse (mode_line_string_list
);
19980 str
= Fmapconcat (intern ("identity"), mode_line_string_list
,
19981 empty_unibyte_string
);
19984 unbind_to (count
, Qnil
);
19988 /* Write a null-terminated, right justified decimal representation of
19989 the positive integer D to BUF using a minimal field width WIDTH. */
19992 pint2str (register char *buf
, register int width
, register EMACS_INT d
)
19994 register char *p
= buf
;
20002 *p
++ = d
% 10 + '0';
20007 for (width
-= (int) (p
- buf
); width
> 0; --width
)
20018 /* Write a null-terminated, right justified decimal and "human
20019 readable" representation of the nonnegative integer D to BUF using
20020 a minimal field width WIDTH. D should be smaller than 999.5e24. */
20022 static const char power_letter
[] =
20036 pint2hrstr (char *buf
, int width
, EMACS_INT d
)
20038 /* We aim to represent the nonnegative integer D as
20039 QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
20040 EMACS_INT quotient
= d
;
20042 /* -1 means: do not use TENTHS. */
20046 /* Length of QUOTIENT.TENTHS as a string. */
20052 if (1000 <= quotient
)
20054 /* Scale to the appropriate EXPONENT. */
20057 remainder
= quotient
% 1000;
20061 while (1000 <= quotient
);
20063 /* Round to nearest and decide whether to use TENTHS or not. */
20066 tenths
= remainder
/ 100;
20067 if (50 <= remainder
% 100)
20074 if (quotient
== 10)
20082 if (500 <= remainder
)
20084 if (quotient
< 999)
20095 /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
20096 if (tenths
== -1 && quotient
<= 99)
20103 p
= psuffix
= buf
+ max (width
, length
);
20105 /* Print EXPONENT. */
20106 *psuffix
++ = power_letter
[exponent
];
20109 /* Print TENTHS. */
20112 *--p
= '0' + tenths
;
20116 /* Print QUOTIENT. */
20119 int digit
= quotient
% 10;
20120 *--p
= '0' + digit
;
20122 while ((quotient
/= 10) != 0);
20124 /* Print leading spaces. */
20129 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
20130 If EOL_FLAG is 1, set also a mnemonic character for end-of-line
20131 type of CODING_SYSTEM. Return updated pointer into BUF. */
20133 static unsigned char invalid_eol_type
[] = "(*invalid*)";
20136 decode_mode_spec_coding (Lisp_Object coding_system
, register char *buf
, int eol_flag
)
20139 int multibyte
= !NILP (BVAR (current_buffer
, enable_multibyte_characters
));
20140 const unsigned char *eol_str
;
20142 /* The EOL conversion we are using. */
20143 Lisp_Object eoltype
;
20145 val
= CODING_SYSTEM_SPEC (coding_system
);
20148 if (!VECTORP (val
)) /* Not yet decided. */
20153 eoltype
= eol_mnemonic_undecided
;
20154 /* Don't mention EOL conversion if it isn't decided. */
20159 Lisp_Object eolvalue
;
20161 attrs
= AREF (val
, 0);
20162 eolvalue
= AREF (val
, 2);
20165 *buf
++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs
));
20169 /* The EOL conversion that is normal on this system. */
20171 if (NILP (eolvalue
)) /* Not yet decided. */
20172 eoltype
= eol_mnemonic_undecided
;
20173 else if (VECTORP (eolvalue
)) /* Not yet decided. */
20174 eoltype
= eol_mnemonic_undecided
;
20175 else /* eolvalue is Qunix, Qdos, or Qmac. */
20176 eoltype
= (EQ (eolvalue
, Qunix
)
20177 ? eol_mnemonic_unix
20178 : (EQ (eolvalue
, Qdos
) == 1
20179 ? eol_mnemonic_dos
: eol_mnemonic_mac
));
20185 /* Mention the EOL conversion if it is not the usual one. */
20186 if (STRINGP (eoltype
))
20188 eol_str
= SDATA (eoltype
);
20189 eol_str_len
= SBYTES (eoltype
);
20191 else if (CHARACTERP (eoltype
))
20193 unsigned char *tmp
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
);
20194 eol_str_len
= CHAR_STRING (XINT (eoltype
), tmp
);
20199 eol_str
= invalid_eol_type
;
20200 eol_str_len
= sizeof (invalid_eol_type
) - 1;
20202 memcpy (buf
, eol_str
, eol_str_len
);
20203 buf
+= eol_str_len
;
20209 /* Return a string for the output of a mode line %-spec for window W,
20210 generated by character C. FIELD_WIDTH > 0 means pad the string
20211 returned with spaces to that value. Return a Lisp string in
20212 *STRING if the resulting string is taken from that Lisp string.
20214 Note we operate on the current buffer for most purposes,
20215 the exception being w->base_line_pos. */
20217 static char lots_of_dashes
[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
20219 static const char *
20220 decode_mode_spec (struct window
*w
, register int c
, int field_width
,
20221 Lisp_Object
*string
)
20224 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
20225 char *decode_mode_spec_buf
= f
->decode_mode_spec_buffer
;
20226 struct buffer
*b
= current_buffer
;
20234 if (!NILP (BVAR (b
, read_only
)))
20236 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
20241 /* This differs from %* only for a modified read-only buffer. */
20242 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
20244 if (!NILP (BVAR (b
, read_only
)))
20249 /* This differs from %* in ignoring read-only-ness. */
20250 if (BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
20262 if (command_loop_level
> 5)
20264 p
= decode_mode_spec_buf
;
20265 for (i
= 0; i
< command_loop_level
; i
++)
20268 return decode_mode_spec_buf
;
20276 if (command_loop_level
> 5)
20278 p
= decode_mode_spec_buf
;
20279 for (i
= 0; i
< command_loop_level
; i
++)
20282 return decode_mode_spec_buf
;
20289 /* Let lots_of_dashes be a string of infinite length. */
20290 if (mode_line_target
== MODE_LINE_NOPROP
||
20291 mode_line_target
== MODE_LINE_STRING
)
20293 if (field_width
<= 0
20294 || field_width
> sizeof (lots_of_dashes
))
20296 for (i
= 0; i
< FRAME_MESSAGE_BUF_SIZE (f
) - 1; ++i
)
20297 decode_mode_spec_buf
[i
] = '-';
20298 decode_mode_spec_buf
[i
] = '\0';
20299 return decode_mode_spec_buf
;
20302 return lots_of_dashes
;
20306 obj
= BVAR (b
, name
);
20310 /* %c and %l are ignored in `frame-title-format'.
20311 (In redisplay_internal, the frame title is drawn _before_ the
20312 windows are updated, so the stuff which depends on actual
20313 window contents (such as %l) may fail to render properly, or
20314 even crash emacs.) */
20315 if (mode_line_target
== MODE_LINE_TITLE
)
20319 EMACS_INT col
= current_column ();
20320 w
->column_number_displayed
= make_number (col
);
20321 pint2str (decode_mode_spec_buf
, field_width
, col
);
20322 return decode_mode_spec_buf
;
20326 #ifndef SYSTEM_MALLOC
20328 if (NILP (Vmemory_full
))
20331 return "!MEM FULL! ";
20338 /* %F displays the frame name. */
20339 if (!NILP (f
->title
))
20340 return SSDATA (f
->title
);
20341 if (f
->explicit_name
|| ! FRAME_WINDOW_P (f
))
20342 return SSDATA (f
->name
);
20346 obj
= BVAR (b
, filename
);
20351 EMACS_INT size
= ZV
- BEGV
;
20352 pint2str (decode_mode_spec_buf
, field_width
, size
);
20353 return decode_mode_spec_buf
;
20358 EMACS_INT size
= ZV
- BEGV
;
20359 pint2hrstr (decode_mode_spec_buf
, field_width
, size
);
20360 return decode_mode_spec_buf
;
20365 EMACS_INT startpos
, startpos_byte
, line
, linepos
, linepos_byte
;
20366 EMACS_INT topline
, nlines
, height
;
20369 /* %c and %l are ignored in `frame-title-format'. */
20370 if (mode_line_target
== MODE_LINE_TITLE
)
20373 startpos
= XMARKER (w
->start
)->charpos
;
20374 startpos_byte
= marker_byte_position (w
->start
);
20375 height
= WINDOW_TOTAL_LINES (w
);
20377 /* If we decided that this buffer isn't suitable for line numbers,
20378 don't forget that too fast. */
20379 if (EQ (w
->base_line_pos
, w
->buffer
))
20381 /* But do forget it, if the window shows a different buffer now. */
20382 else if (BUFFERP (w
->base_line_pos
))
20383 w
->base_line_pos
= Qnil
;
20385 /* If the buffer is very big, don't waste time. */
20386 if (INTEGERP (Vline_number_display_limit
)
20387 && BUF_ZV (b
) - BUF_BEGV (b
) > XINT (Vline_number_display_limit
))
20389 w
->base_line_pos
= Qnil
;
20390 w
->base_line_number
= Qnil
;
20394 if (INTEGERP (w
->base_line_number
)
20395 && INTEGERP (w
->base_line_pos
)
20396 && XFASTINT (w
->base_line_pos
) <= startpos
)
20398 line
= XFASTINT (w
->base_line_number
);
20399 linepos
= XFASTINT (w
->base_line_pos
);
20400 linepos_byte
= buf_charpos_to_bytepos (b
, linepos
);
20405 linepos
= BUF_BEGV (b
);
20406 linepos_byte
= BUF_BEGV_BYTE (b
);
20409 /* Count lines from base line to window start position. */
20410 nlines
= display_count_lines (linepos_byte
,
20414 topline
= nlines
+ line
;
20416 /* Determine a new base line, if the old one is too close
20417 or too far away, or if we did not have one.
20418 "Too close" means it's plausible a scroll-down would
20419 go back past it. */
20420 if (startpos
== BUF_BEGV (b
))
20422 w
->base_line_number
= make_number (topline
);
20423 w
->base_line_pos
= make_number (BUF_BEGV (b
));
20425 else if (nlines
< height
+ 25 || nlines
> height
* 3 + 50
20426 || linepos
== BUF_BEGV (b
))
20428 EMACS_INT limit
= BUF_BEGV (b
);
20429 EMACS_INT limit_byte
= BUF_BEGV_BYTE (b
);
20430 EMACS_INT position
;
20431 EMACS_INT distance
=
20432 (height
* 2 + 30) * line_number_display_limit_width
;
20434 if (startpos
- distance
> limit
)
20436 limit
= startpos
- distance
;
20437 limit_byte
= CHAR_TO_BYTE (limit
);
20440 nlines
= display_count_lines (startpos_byte
,
20442 - (height
* 2 + 30),
20444 /* If we couldn't find the lines we wanted within
20445 line_number_display_limit_width chars per line,
20446 give up on line numbers for this window. */
20447 if (position
== limit_byte
&& limit
== startpos
- distance
)
20449 w
->base_line_pos
= w
->buffer
;
20450 w
->base_line_number
= Qnil
;
20454 w
->base_line_number
= make_number (topline
- nlines
);
20455 w
->base_line_pos
= make_number (BYTE_TO_CHAR (position
));
20458 /* Now count lines from the start pos to point. */
20459 nlines
= display_count_lines (startpos_byte
,
20460 PT_BYTE
, PT
, &junk
);
20462 /* Record that we did display the line number. */
20463 line_number_displayed
= 1;
20465 /* Make the string to show. */
20466 pint2str (decode_mode_spec_buf
, field_width
, topline
+ nlines
);
20467 return decode_mode_spec_buf
;
20470 char* p
= decode_mode_spec_buf
;
20471 int pad
= field_width
- 2;
20477 return decode_mode_spec_buf
;
20483 obj
= BVAR (b
, mode_name
);
20487 if (BUF_BEGV (b
) > BUF_BEG (b
) || BUF_ZV (b
) < BUF_Z (b
))
20493 EMACS_INT pos
= marker_position (w
->start
);
20494 EMACS_INT total
= BUF_ZV (b
) - BUF_BEGV (b
);
20496 if (XFASTINT (w
->window_end_pos
) <= BUF_Z (b
) - BUF_ZV (b
))
20498 if (pos
<= BUF_BEGV (b
))
20503 else if (pos
<= BUF_BEGV (b
))
20507 if (total
> 1000000)
20508 /* Do it differently for a large value, to avoid overflow. */
20509 total
= ((pos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
20511 total
= ((pos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
20512 /* We can't normally display a 3-digit number,
20513 so get us a 2-digit number that is close. */
20516 sprintf (decode_mode_spec_buf
, "%2"pI
"d%%", total
);
20517 return decode_mode_spec_buf
;
20521 /* Display percentage of size above the bottom of the screen. */
20524 EMACS_INT toppos
= marker_position (w
->start
);
20525 EMACS_INT botpos
= BUF_Z (b
) - XFASTINT (w
->window_end_pos
);
20526 EMACS_INT total
= BUF_ZV (b
) - BUF_BEGV (b
);
20528 if (botpos
>= BUF_ZV (b
))
20530 if (toppos
<= BUF_BEGV (b
))
20537 if (total
> 1000000)
20538 /* Do it differently for a large value, to avoid overflow. */
20539 total
= ((botpos
- BUF_BEGV (b
)) + (total
/ 100) - 1) / (total
/ 100);
20541 total
= ((botpos
- BUF_BEGV (b
)) * 100 + total
- 1) / total
;
20542 /* We can't normally display a 3-digit number,
20543 so get us a 2-digit number that is close. */
20546 if (toppos
<= BUF_BEGV (b
))
20547 sprintf (decode_mode_spec_buf
, "Top%2"pI
"d%%", total
);
20549 sprintf (decode_mode_spec_buf
, "%2"pI
"d%%", total
);
20550 return decode_mode_spec_buf
;
20555 /* status of process */
20556 obj
= Fget_buffer_process (Fcurrent_buffer ());
20558 return "no process";
20560 obj
= Fsymbol_name (Fprocess_status (obj
));
20566 int count
= inhibit_garbage_collection ();
20567 Lisp_Object val
= call1 (intern ("file-remote-p"),
20568 BVAR (current_buffer
, directory
));
20569 unbind_to (count
, Qnil
);
20577 case 't': /* indicate TEXT or BINARY */
20581 /* coding-system (not including end-of-line format) */
20583 /* coding-system (including end-of-line type) */
20585 int eol_flag
= (c
== 'Z');
20586 char *p
= decode_mode_spec_buf
;
20588 if (! FRAME_WINDOW_P (f
))
20590 /* No need to mention EOL here--the terminal never needs
20591 to do EOL conversion. */
20592 p
= decode_mode_spec_coding (CODING_ID_NAME
20593 (FRAME_KEYBOARD_CODING (f
)->id
),
20595 p
= decode_mode_spec_coding (CODING_ID_NAME
20596 (FRAME_TERMINAL_CODING (f
)->id
),
20599 p
= decode_mode_spec_coding (BVAR (b
, buffer_file_coding_system
),
20602 #if 0 /* This proves to be annoying; I think we can do without. -- rms. */
20603 #ifdef subprocesses
20604 obj
= Fget_buffer_process (Fcurrent_buffer ());
20605 if (PROCESSP (obj
))
20607 p
= decode_mode_spec_coding (XPROCESS (obj
)->decode_coding_system
,
20609 p
= decode_mode_spec_coding (XPROCESS (obj
)->encode_coding_system
,
20612 #endif /* subprocesses */
20615 return decode_mode_spec_buf
;
20622 return SSDATA (obj
);
20629 /* Count up to COUNT lines starting from START_BYTE.
20630 But don't go beyond LIMIT_BYTE.
20631 Return the number of lines thus found (always nonnegative).
20633 Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */
20636 display_count_lines (EMACS_INT start_byte
,
20637 EMACS_INT limit_byte
, EMACS_INT count
,
20638 EMACS_INT
*byte_pos_ptr
)
20640 register unsigned char *cursor
;
20641 unsigned char *base
;
20643 register EMACS_INT ceiling
;
20644 register unsigned char *ceiling_addr
;
20645 EMACS_INT orig_count
= count
;
20647 /* If we are not in selective display mode,
20648 check only for newlines. */
20649 int selective_display
= (!NILP (BVAR (current_buffer
, selective_display
))
20650 && !INTEGERP (BVAR (current_buffer
, selective_display
)));
20654 while (start_byte
< limit_byte
)
20656 ceiling
= BUFFER_CEILING_OF (start_byte
);
20657 ceiling
= min (limit_byte
- 1, ceiling
);
20658 ceiling_addr
= BYTE_POS_ADDR (ceiling
) + 1;
20659 base
= (cursor
= BYTE_POS_ADDR (start_byte
));
20662 if (selective_display
)
20663 while (*cursor
!= '\n' && *cursor
!= 015 && ++cursor
!= ceiling_addr
)
20666 while (*cursor
!= '\n' && ++cursor
!= ceiling_addr
)
20669 if (cursor
!= ceiling_addr
)
20673 start_byte
+= cursor
- base
+ 1;
20674 *byte_pos_ptr
= start_byte
;
20678 if (++cursor
== ceiling_addr
)
20684 start_byte
+= cursor
- base
;
20689 while (start_byte
> limit_byte
)
20691 ceiling
= BUFFER_FLOOR_OF (start_byte
- 1);
20692 ceiling
= max (limit_byte
, ceiling
);
20693 ceiling_addr
= BYTE_POS_ADDR (ceiling
) - 1;
20694 base
= (cursor
= BYTE_POS_ADDR (start_byte
- 1) + 1);
20697 if (selective_display
)
20698 while (--cursor
!= ceiling_addr
20699 && *cursor
!= '\n' && *cursor
!= 015)
20702 while (--cursor
!= ceiling_addr
&& *cursor
!= '\n')
20705 if (cursor
!= ceiling_addr
)
20709 start_byte
+= cursor
- base
+ 1;
20710 *byte_pos_ptr
= start_byte
;
20711 /* When scanning backwards, we should
20712 not count the newline posterior to which we stop. */
20713 return - orig_count
- 1;
20719 /* Here we add 1 to compensate for the last decrement
20720 of CURSOR, which took it past the valid range. */
20721 start_byte
+= cursor
- base
+ 1;
20725 *byte_pos_ptr
= limit_byte
;
20728 return - orig_count
+ count
;
20729 return orig_count
- count
;
20735 /***********************************************************************
20737 ***********************************************************************/
20739 /* Display a NUL-terminated string, starting with index START.
20741 If STRING is non-null, display that C string. Otherwise, the Lisp
20742 string LISP_STRING is displayed. There's a case that STRING is
20743 non-null and LISP_STRING is not nil. It means STRING is a string
20744 data of LISP_STRING. In that case, we display LISP_STRING while
20745 ignoring its text properties.
20747 If FACE_STRING is not nil, FACE_STRING_POS is a position in
20748 FACE_STRING. Display STRING or LISP_STRING with the face at
20749 FACE_STRING_POS in FACE_STRING:
20751 Display the string in the environment given by IT, but use the
20752 standard display table, temporarily.
20754 FIELD_WIDTH is the minimum number of output glyphs to produce.
20755 If STRING has fewer characters than FIELD_WIDTH, pad to the right
20756 with spaces. If STRING has more characters, more than FIELD_WIDTH
20757 glyphs will be produced. FIELD_WIDTH <= 0 means don't pad.
20759 PRECISION is the maximum number of characters to output from
20760 STRING. PRECISION < 0 means don't truncate the string.
20762 This is roughly equivalent to printf format specifiers:
20764 FIELD_WIDTH PRECISION PRINTF
20765 ----------------------------------------
20771 MULTIBYTE zero means do not display multibyte chars, > 0 means do
20772 display them, and < 0 means obey the current buffer's value of
20773 enable_multibyte_characters.
20775 Value is the number of columns displayed. */
20778 display_string (const char *string
, Lisp_Object lisp_string
, Lisp_Object face_string
,
20779 EMACS_INT face_string_pos
, EMACS_INT start
, struct it
*it
,
20780 int field_width
, int precision
, int max_x
, int multibyte
)
20782 int hpos_at_start
= it
->hpos
;
20783 int saved_face_id
= it
->face_id
;
20784 struct glyph_row
*row
= it
->glyph_row
;
20785 EMACS_INT it_charpos
;
20787 /* Initialize the iterator IT for iteration over STRING beginning
20788 with index START. */
20789 reseat_to_string (it
, NILP (lisp_string
) ? string
: NULL
, lisp_string
, start
,
20790 precision
, field_width
, multibyte
);
20791 if (string
&& STRINGP (lisp_string
))
20792 /* LISP_STRING is the one returned by decode_mode_spec. We should
20793 ignore its text properties. */
20794 it
->stop_charpos
= it
->end_charpos
;
20796 /* If displaying STRING, set up the face of the iterator from
20797 FACE_STRING, if that's given. */
20798 if (STRINGP (face_string
))
20804 = face_at_string_position (it
->w
, face_string
, face_string_pos
,
20805 0, it
->region_beg_charpos
,
20806 it
->region_end_charpos
,
20807 &endptr
, it
->base_face_id
, 0);
20808 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
20809 it
->face_box_p
= face
->box
!= FACE_NO_BOX
;
20812 /* Set max_x to the maximum allowed X position. Don't let it go
20813 beyond the right edge of the window. */
20815 max_x
= it
->last_visible_x
;
20817 max_x
= min (max_x
, it
->last_visible_x
);
20819 /* Skip over display elements that are not visible. because IT->w is
20821 if (it
->current_x
< it
->first_visible_x
)
20822 move_it_in_display_line_to (it
, 100000, it
->first_visible_x
,
20823 MOVE_TO_POS
| MOVE_TO_X
);
20825 row
->ascent
= it
->max_ascent
;
20826 row
->height
= it
->max_ascent
+ it
->max_descent
;
20827 row
->phys_ascent
= it
->max_phys_ascent
;
20828 row
->phys_height
= it
->max_phys_ascent
+ it
->max_phys_descent
;
20829 row
->extra_line_spacing
= it
->max_extra_line_spacing
;
20831 if (STRINGP (it
->string
))
20832 it_charpos
= IT_STRING_CHARPOS (*it
);
20834 it_charpos
= IT_CHARPOS (*it
);
20836 /* This condition is for the case that we are called with current_x
20837 past last_visible_x. */
20838 while (it
->current_x
< max_x
)
20840 int x_before
, x
, n_glyphs_before
, i
, nglyphs
;
20842 /* Get the next display element. */
20843 if (!get_next_display_element (it
))
20846 /* Produce glyphs. */
20847 x_before
= it
->current_x
;
20848 n_glyphs_before
= row
->used
[TEXT_AREA
];
20849 PRODUCE_GLYPHS (it
);
20851 nglyphs
= row
->used
[TEXT_AREA
] - n_glyphs_before
;
20854 while (i
< nglyphs
)
20856 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + n_glyphs_before
+ i
;
20858 if (it
->line_wrap
!= TRUNCATE
20859 && x
+ glyph
->pixel_width
> max_x
)
20861 /* End of continued line or max_x reached. */
20862 if (CHAR_GLYPH_PADDING_P (*glyph
))
20864 /* A wide character is unbreakable. */
20865 if (row
->reversed_p
)
20866 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
20867 - n_glyphs_before
);
20868 row
->used
[TEXT_AREA
] = n_glyphs_before
;
20869 it
->current_x
= x_before
;
20873 if (row
->reversed_p
)
20874 unproduce_glyphs (it
, row
->used
[TEXT_AREA
]
20875 - (n_glyphs_before
+ i
));
20876 row
->used
[TEXT_AREA
] = n_glyphs_before
+ i
;
20881 else if (x
+ glyph
->pixel_width
>= it
->first_visible_x
)
20883 /* Glyph is at least partially visible. */
20885 if (x
< it
->first_visible_x
)
20886 row
->x
= x
- it
->first_visible_x
;
20890 /* Glyph is off the left margin of the display area.
20891 Should not happen. */
20895 row
->ascent
= max (row
->ascent
, it
->max_ascent
);
20896 row
->height
= max (row
->height
, it
->max_ascent
+ it
->max_descent
);
20897 row
->phys_ascent
= max (row
->phys_ascent
, it
->max_phys_ascent
);
20898 row
->phys_height
= max (row
->phys_height
,
20899 it
->max_phys_ascent
+ it
->max_phys_descent
);
20900 row
->extra_line_spacing
= max (row
->extra_line_spacing
,
20901 it
->max_extra_line_spacing
);
20902 x
+= glyph
->pixel_width
;
20906 /* Stop if max_x reached. */
20910 /* Stop at line ends. */
20911 if (ITERATOR_AT_END_OF_LINE_P (it
))
20913 it
->continuation_lines_width
= 0;
20917 set_iterator_to_next (it
, 1);
20918 if (STRINGP (it
->string
))
20919 it_charpos
= IT_STRING_CHARPOS (*it
);
20921 it_charpos
= IT_CHARPOS (*it
);
20923 /* Stop if truncating at the right edge. */
20924 if (it
->line_wrap
== TRUNCATE
20925 && it
->current_x
>= it
->last_visible_x
)
20927 /* Add truncation mark, but don't do it if the line is
20928 truncated at a padding space. */
20929 if (it_charpos
< it
->string_nchars
)
20931 if (!FRAME_WINDOW_P (it
->f
))
20935 if (it
->current_x
> it
->last_visible_x
)
20937 if (!row
->reversed_p
)
20939 for (ii
= row
->used
[TEXT_AREA
] - 1; ii
> 0; --ii
)
20940 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
20945 for (ii
= 0; ii
< row
->used
[TEXT_AREA
]; ii
++)
20946 if (!CHAR_GLYPH_PADDING_P (row
->glyphs
[TEXT_AREA
][ii
]))
20948 unproduce_glyphs (it
, ii
+ 1);
20949 ii
= row
->used
[TEXT_AREA
] - (ii
+ 1);
20951 for (n
= row
->used
[TEXT_AREA
]; ii
< n
; ++ii
)
20953 row
->used
[TEXT_AREA
] = ii
;
20954 produce_special_glyphs (it
, IT_TRUNCATION
);
20957 produce_special_glyphs (it
, IT_TRUNCATION
);
20959 row
->truncated_on_right_p
= 1;
20965 /* Maybe insert a truncation at the left. */
20966 if (it
->first_visible_x
20969 if (!FRAME_WINDOW_P (it
->f
))
20970 insert_left_trunc_glyphs (it
);
20971 row
->truncated_on_left_p
= 1;
20974 it
->face_id
= saved_face_id
;
20976 /* Value is number of columns displayed. */
20977 return it
->hpos
- hpos_at_start
;
20982 /* This is like a combination of memq and assq. Return 1/2 if PROPVAL
20983 appears as an element of LIST or as the car of an element of LIST.
20984 If PROPVAL is a list, compare each element against LIST in that
20985 way, and return 1/2 if any element of PROPVAL is found in LIST.
20986 Otherwise return 0. This function cannot quit.
20987 The return value is 2 if the text is invisible but with an ellipsis
20988 and 1 if it's invisible and without an ellipsis. */
20991 invisible_p (register Lisp_Object propval
, Lisp_Object list
)
20993 register Lisp_Object tail
, proptail
;
20995 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
20997 register Lisp_Object tem
;
20999 if (EQ (propval
, tem
))
21001 if (CONSP (tem
) && EQ (propval
, XCAR (tem
)))
21002 return NILP (XCDR (tem
)) ? 1 : 2;
21005 if (CONSP (propval
))
21007 for (proptail
= propval
; CONSP (proptail
); proptail
= XCDR (proptail
))
21009 Lisp_Object propelt
;
21010 propelt
= XCAR (proptail
);
21011 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
21013 register Lisp_Object tem
;
21015 if (EQ (propelt
, tem
))
21017 if (CONSP (tem
) && EQ (propelt
, XCAR (tem
)))
21018 return NILP (XCDR (tem
)) ? 1 : 2;
21026 DEFUN ("invisible-p", Finvisible_p
, Sinvisible_p
, 1, 1, 0,
21027 doc
: /* Non-nil if the property makes the text invisible.
21028 POS-OR-PROP can be a marker or number, in which case it is taken to be
21029 a position in the current buffer and the value of the `invisible' property
21030 is checked; or it can be some other value, which is then presumed to be the
21031 value of the `invisible' property of the text of interest.
21032 The non-nil value returned can be t for truly invisible text or something
21033 else if the text is replaced by an ellipsis. */)
21034 (Lisp_Object pos_or_prop
)
21037 = (NATNUMP (pos_or_prop
) || MARKERP (pos_or_prop
)
21038 ? Fget_char_property (pos_or_prop
, Qinvisible
, Qnil
)
21040 int invis
= TEXT_PROP_MEANS_INVISIBLE (prop
);
21041 return (invis
== 0 ? Qnil
21043 : make_number (invis
));
21046 /* Calculate a width or height in pixels from a specification using
21047 the following elements:
21050 NUM - a (fractional) multiple of the default font width/height
21051 (NUM) - specifies exactly NUM pixels
21052 UNIT - a fixed number of pixels, see below.
21053 ELEMENT - size of a display element in pixels, see below.
21054 (NUM . SPEC) - equals NUM * SPEC
21055 (+ SPEC SPEC ...) - add pixel values
21056 (- SPEC SPEC ...) - subtract pixel values
21057 (- SPEC) - negate pixel value
21060 INT or FLOAT - a number constant
21061 SYMBOL - use symbol's (buffer local) variable binding.
21064 in - pixels per inch *)
21065 mm - pixels per 1/1000 meter *)
21066 cm - pixels per 1/100 meter *)
21067 width - width of current font in pixels.
21068 height - height of current font in pixels.
21070 *) using the ratio(s) defined in display-pixels-per-inch.
21074 left-fringe - left fringe width in pixels
21075 right-fringe - right fringe width in pixels
21077 left-margin - left margin width in pixels
21078 right-margin - right margin width in pixels
21080 scroll-bar - scroll-bar area width in pixels
21084 Pixels corresponding to 5 inches:
21087 Total width of non-text areas on left side of window (if scroll-bar is on left):
21088 '(space :width (+ left-fringe left-margin scroll-bar))
21090 Align to first text column (in header line):
21091 '(space :align-to 0)
21093 Align to middle of text area minus half the width of variable `my-image'
21094 containing a loaded image:
21095 '(space :align-to (0.5 . (- text my-image)))
21097 Width of left margin minus width of 1 character in the default font:
21098 '(space :width (- left-margin 1))
21100 Width of left margin minus width of 2 characters in the current font:
21101 '(space :width (- left-margin (2 . width)))
21103 Center 1 character over left-margin (in header line):
21104 '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
21106 Different ways to express width of left fringe plus left margin minus one pixel:
21107 '(space :width (- (+ left-fringe left-margin) (1)))
21108 '(space :width (+ left-fringe left-margin (- (1))))
21109 '(space :width (+ left-fringe left-margin (-1)))
21113 #define NUMVAL(X) \
21114 ((INTEGERP (X) || FLOATP (X)) \
21119 calc_pixel_width_or_height (double *res
, struct it
*it
, Lisp_Object prop
,
21120 struct font
*font
, int width_p
, int *align_to
)
21124 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
21125 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
21128 return OK_PIXELS (0);
21130 xassert (FRAME_LIVE_P (it
->f
));
21132 if (SYMBOLP (prop
))
21134 if (SCHARS (SYMBOL_NAME (prop
)) == 2)
21136 char *unit
= SSDATA (SYMBOL_NAME (prop
));
21138 if (unit
[0] == 'i' && unit
[1] == 'n')
21140 else if (unit
[0] == 'm' && unit
[1] == 'm')
21142 else if (unit
[0] == 'c' && unit
[1] == 'm')
21149 #ifdef HAVE_WINDOW_SYSTEM
21150 if (FRAME_WINDOW_P (it
->f
)
21152 ? FRAME_X_DISPLAY_INFO (it
->f
)->resx
21153 : FRAME_X_DISPLAY_INFO (it
->f
)->resy
),
21155 return OK_PIXELS (ppi
/ pixels
);
21158 if ((ppi
= NUMVAL (Vdisplay_pixels_per_inch
), ppi
> 0)
21159 || (CONSP (Vdisplay_pixels_per_inch
)
21161 ? NUMVAL (XCAR (Vdisplay_pixels_per_inch
))
21162 : NUMVAL (XCDR (Vdisplay_pixels_per_inch
))),
21164 return OK_PIXELS (ppi
/ pixels
);
21170 #ifdef HAVE_WINDOW_SYSTEM
21171 if (EQ (prop
, Qheight
))
21172 return OK_PIXELS (font
? FONT_HEIGHT (font
) : FRAME_LINE_HEIGHT (it
->f
));
21173 if (EQ (prop
, Qwidth
))
21174 return OK_PIXELS (font
? FONT_WIDTH (font
) : FRAME_COLUMN_WIDTH (it
->f
));
21176 if (EQ (prop
, Qheight
) || EQ (prop
, Qwidth
))
21177 return OK_PIXELS (1);
21180 if (EQ (prop
, Qtext
))
21181 return OK_PIXELS (width_p
21182 ? window_box_width (it
->w
, TEXT_AREA
)
21183 : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it
->w
));
21185 if (align_to
&& *align_to
< 0)
21188 if (EQ (prop
, Qleft
))
21189 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
));
21190 if (EQ (prop
, Qright
))
21191 return OK_ALIGN_TO (window_box_right_offset (it
->w
, TEXT_AREA
));
21192 if (EQ (prop
, Qcenter
))
21193 return OK_ALIGN_TO (window_box_left_offset (it
->w
, TEXT_AREA
)
21194 + window_box_width (it
->w
, TEXT_AREA
) / 2);
21195 if (EQ (prop
, Qleft_fringe
))
21196 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
21197 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it
->w
)
21198 : window_box_right_offset (it
->w
, LEFT_MARGIN_AREA
));
21199 if (EQ (prop
, Qright_fringe
))
21200 return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
21201 ? window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
21202 : window_box_right_offset (it
->w
, TEXT_AREA
));
21203 if (EQ (prop
, Qleft_margin
))
21204 return OK_ALIGN_TO (window_box_left_offset (it
->w
, LEFT_MARGIN_AREA
));
21205 if (EQ (prop
, Qright_margin
))
21206 return OK_ALIGN_TO (window_box_left_offset (it
->w
, RIGHT_MARGIN_AREA
));
21207 if (EQ (prop
, Qscroll_bar
))
21208 return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it
->w
)
21210 : (window_box_right_offset (it
->w
, RIGHT_MARGIN_AREA
)
21211 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it
->w
)
21212 ? WINDOW_RIGHT_FRINGE_WIDTH (it
->w
)
21217 if (EQ (prop
, Qleft_fringe
))
21218 return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it
->w
));
21219 if (EQ (prop
, Qright_fringe
))
21220 return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it
->w
));
21221 if (EQ (prop
, Qleft_margin
))
21222 return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it
->w
));
21223 if (EQ (prop
, Qright_margin
))
21224 return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it
->w
));
21225 if (EQ (prop
, Qscroll_bar
))
21226 return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it
->w
));
21229 prop
= Fbuffer_local_value (prop
, it
->w
->buffer
);
21232 if (INTEGERP (prop
) || FLOATP (prop
))
21234 int base_unit
= (width_p
21235 ? FRAME_COLUMN_WIDTH (it
->f
)
21236 : FRAME_LINE_HEIGHT (it
->f
));
21237 return OK_PIXELS (XFLOATINT (prop
) * base_unit
);
21242 Lisp_Object car
= XCAR (prop
);
21243 Lisp_Object cdr
= XCDR (prop
);
21247 #ifdef HAVE_WINDOW_SYSTEM
21248 if (FRAME_WINDOW_P (it
->f
)
21249 && valid_image_p (prop
))
21251 int id
= lookup_image (it
->f
, prop
);
21252 struct image
*img
= IMAGE_FROM_ID (it
->f
, id
);
21254 return OK_PIXELS (width_p
? img
->width
: img
->height
);
21257 if (EQ (car
, Qplus
) || EQ (car
, Qminus
))
21263 while (CONSP (cdr
))
21265 if (!calc_pixel_width_or_height (&px
, it
, XCAR (cdr
),
21266 font
, width_p
, align_to
))
21269 pixels
= (EQ (car
, Qplus
) ? px
: -px
), first
= 0;
21274 if (EQ (car
, Qminus
))
21276 return OK_PIXELS (pixels
);
21279 car
= Fbuffer_local_value (car
, it
->w
->buffer
);
21282 if (INTEGERP (car
) || FLOATP (car
))
21285 pixels
= XFLOATINT (car
);
21287 return OK_PIXELS (pixels
);
21288 if (calc_pixel_width_or_height (&fact
, it
, cdr
,
21289 font
, width_p
, align_to
))
21290 return OK_PIXELS (pixels
* fact
);
21301 /***********************************************************************
21303 ***********************************************************************/
21305 #ifdef HAVE_WINDOW_SYSTEM
21310 dump_glyph_string (s
)
21311 struct glyph_string
*s
;
21313 fprintf (stderr
, "glyph string\n");
21314 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
21315 s
->x
, s
->y
, s
->width
, s
->height
);
21316 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
21317 fprintf (stderr
, " hl = %d\n", s
->hl
);
21318 fprintf (stderr
, " left overhang = %d, right = %d\n",
21319 s
->left_overhang
, s
->right_overhang
);
21320 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
21321 fprintf (stderr
, " extends to end of line = %d\n",
21322 s
->extends_to_end_of_line_p
);
21323 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
21324 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
21327 #endif /* GLYPH_DEBUG */
21329 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
21330 of XChar2b structures for S; it can't be allocated in
21331 init_glyph_string because it must be allocated via `alloca'. W
21332 is the window on which S is drawn. ROW and AREA are the glyph row
21333 and area within the row from which S is constructed. START is the
21334 index of the first glyph structure covered by S. HL is a
21335 face-override for drawing S. */
21338 #define OPTIONAL_HDC(hdc) HDC hdc,
21339 #define DECLARE_HDC(hdc) HDC hdc;
21340 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
21341 #define RELEASE_HDC(hdc, f) release_frame_dc ((f), (hdc))
21344 #ifndef OPTIONAL_HDC
21345 #define OPTIONAL_HDC(hdc)
21346 #define DECLARE_HDC(hdc)
21347 #define ALLOCATE_HDC(hdc, f)
21348 #define RELEASE_HDC(hdc, f)
21352 init_glyph_string (struct glyph_string
*s
,
21354 XChar2b
*char2b
, struct window
*w
, struct glyph_row
*row
,
21355 enum glyph_row_area area
, int start
, enum draw_glyphs_face hl
)
21357 memset (s
, 0, sizeof *s
);
21359 s
->f
= XFRAME (w
->frame
);
21363 s
->display
= FRAME_X_DISPLAY (s
->f
);
21364 s
->window
= FRAME_X_WINDOW (s
->f
);
21365 s
->char2b
= char2b
;
21369 s
->first_glyph
= row
->glyphs
[area
] + start
;
21370 s
->height
= row
->height
;
21371 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
21372 s
->ybase
= s
->y
+ row
->ascent
;
21376 /* Append the list of glyph strings with head H and tail T to the list
21377 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
21380 append_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
21381 struct glyph_string
*h
, struct glyph_string
*t
)
21395 /* Prepend the list of glyph strings with head H and tail T to the
21396 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
21400 prepend_glyph_string_lists (struct glyph_string
**head
, struct glyph_string
**tail
,
21401 struct glyph_string
*h
, struct glyph_string
*t
)
21415 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
21416 Set *HEAD and *TAIL to the resulting list. */
21419 append_glyph_string (struct glyph_string
**head
, struct glyph_string
**tail
,
21420 struct glyph_string
*s
)
21422 s
->next
= s
->prev
= NULL
;
21423 append_glyph_string_lists (head
, tail
, s
, s
);
21427 /* Get face and two-byte form of character C in face FACE_ID on frame F.
21428 The encoding of C is returned in *CHAR2B. DISPLAY_P non-zero means
21429 make sure that X resources for the face returned are allocated.
21430 Value is a pointer to a realized face that is ready for display if
21431 DISPLAY_P is non-zero. */
21433 static INLINE
struct face
*
21434 get_char_face_and_encoding (struct frame
*f
, int c
, int face_id
,
21435 XChar2b
*char2b
, int display_p
)
21437 struct face
*face
= FACE_FROM_ID (f
, face_id
);
21441 unsigned code
= face
->font
->driver
->encode_char (face
->font
, c
);
21443 if (code
!= FONT_INVALID_CODE
)
21444 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
21446 STORE_XCHAR2B (char2b
, 0, 0);
21449 /* Make sure X resources of the face are allocated. */
21450 #ifdef HAVE_X_WINDOWS
21454 xassert (face
!= NULL
);
21455 PREPARE_FACE_FOR_DISPLAY (f
, face
);
21462 /* Get face and two-byte form of character glyph GLYPH on frame F.
21463 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
21464 a pointer to a realized face that is ready for display. */
21466 static INLINE
struct face
*
21467 get_glyph_face_and_encoding (struct frame
*f
, struct glyph
*glyph
,
21468 XChar2b
*char2b
, int *two_byte_p
)
21472 xassert (glyph
->type
== CHAR_GLYPH
);
21473 face
= FACE_FROM_ID (f
, glyph
->face_id
);
21482 if (CHAR_BYTE8_P (glyph
->u
.ch
))
21483 code
= CHAR_TO_BYTE8 (glyph
->u
.ch
);
21485 code
= face
->font
->driver
->encode_char (face
->font
, glyph
->u
.ch
);
21487 if (code
!= FONT_INVALID_CODE
)
21488 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
21490 STORE_XCHAR2B (char2b
, 0, 0);
21493 /* Make sure X resources of the face are allocated. */
21494 xassert (face
!= NULL
);
21495 PREPARE_FACE_FOR_DISPLAY (f
, face
);
21500 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
21501 Retunr 1 if FONT has a glyph for C, otherwise return 0. */
21504 get_char_glyph_code (int c
, struct font
*font
, XChar2b
*char2b
)
21508 if (CHAR_BYTE8_P (c
))
21509 code
= CHAR_TO_BYTE8 (c
);
21511 code
= font
->driver
->encode_char (font
, c
);
21513 if (code
== FONT_INVALID_CODE
)
21515 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
21520 /* Fill glyph string S with composition components specified by S->cmp.
21522 BASE_FACE is the base face of the composition.
21523 S->cmp_from is the index of the first component for S.
21525 OVERLAPS non-zero means S should draw the foreground only, and use
21526 its physical height for clipping. See also draw_glyphs.
21528 Value is the index of a component not in S. */
21531 fill_composite_glyph_string (struct glyph_string
*s
, struct face
*base_face
,
21535 /* For all glyphs of this composition, starting at the offset
21536 S->cmp_from, until we reach the end of the definition or encounter a
21537 glyph that requires the different face, add it to S. */
21542 s
->for_overlaps
= overlaps
;
21545 for (i
= s
->cmp_from
; i
< s
->cmp
->glyph_len
; i
++)
21547 int c
= COMPOSITION_GLYPH (s
->cmp
, i
);
21551 int face_id
= FACE_FOR_CHAR (s
->f
, base_face
->ascii_face
, c
,
21554 face
= get_char_face_and_encoding (s
->f
, c
, face_id
,
21561 s
->font
= s
->face
->font
;
21563 else if (s
->face
!= face
)
21571 /* All glyph strings for the same composition has the same width,
21572 i.e. the width set for the first component of the composition. */
21573 s
->width
= s
->first_glyph
->pixel_width
;
21575 /* If the specified font could not be loaded, use the frame's
21576 default font, but record the fact that we couldn't load it in
21577 the glyph string so that we can draw rectangles for the
21578 characters of the glyph string. */
21579 if (s
->font
== NULL
)
21581 s
->font_not_found_p
= 1;
21582 s
->font
= FRAME_FONT (s
->f
);
21585 /* Adjust base line for subscript/superscript text. */
21586 s
->ybase
+= s
->first_glyph
->voffset
;
21588 /* This glyph string must always be drawn with 16-bit functions. */
21595 fill_gstring_glyph_string (struct glyph_string
*s
, int face_id
,
21596 int start
, int end
, int overlaps
)
21598 struct glyph
*glyph
, *last
;
21599 Lisp_Object lgstring
;
21602 s
->for_overlaps
= overlaps
;
21603 glyph
= s
->row
->glyphs
[s
->area
] + start
;
21604 last
= s
->row
->glyphs
[s
->area
] + end
;
21605 s
->cmp_id
= glyph
->u
.cmp
.id
;
21606 s
->cmp_from
= glyph
->slice
.cmp
.from
;
21607 s
->cmp_to
= glyph
->slice
.cmp
.to
+ 1;
21608 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
21609 lgstring
= composition_gstring_from_id (s
->cmp_id
);
21610 s
->font
= XFONT_OBJECT (LGSTRING_FONT (lgstring
));
21612 while (glyph
< last
21613 && glyph
->u
.cmp
.automatic
21614 && glyph
->u
.cmp
.id
== s
->cmp_id
21615 && s
->cmp_to
== glyph
->slice
.cmp
.from
)
21616 s
->cmp_to
= (glyph
++)->slice
.cmp
.to
+ 1;
21618 for (i
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
21620 Lisp_Object lglyph
= LGSTRING_GLYPH (lgstring
, i
);
21621 unsigned code
= LGLYPH_CODE (lglyph
);
21623 STORE_XCHAR2B ((s
->char2b
+ i
), code
>> 8, code
& 0xFF);
21625 s
->width
= composition_gstring_width (lgstring
, s
->cmp_from
, s
->cmp_to
, NULL
);
21626 return glyph
- s
->row
->glyphs
[s
->area
];
21630 /* Fill glyph string S from a sequence glyphs for glyphless characters.
21631 See the comment of fill_glyph_string for arguments.
21632 Value is the index of the first glyph not in S. */
21636 fill_glyphless_glyph_string (struct glyph_string
*s
, int face_id
,
21637 int start
, int end
, int overlaps
)
21639 struct glyph
*glyph
, *last
;
21642 xassert (s
->first_glyph
->type
== GLYPHLESS_GLYPH
);
21643 s
->for_overlaps
= overlaps
;
21644 glyph
= s
->row
->glyphs
[s
->area
] + start
;
21645 last
= s
->row
->glyphs
[s
->area
] + end
;
21646 voffset
= glyph
->voffset
;
21647 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
21648 s
->font
= s
->face
->font
;
21650 s
->width
= glyph
->pixel_width
;
21652 while (glyph
< last
21653 && glyph
->type
== GLYPHLESS_GLYPH
21654 && glyph
->voffset
== voffset
21655 && glyph
->face_id
== face_id
)
21658 s
->width
+= glyph
->pixel_width
;
21661 s
->ybase
+= voffset
;
21662 return glyph
- s
->row
->glyphs
[s
->area
];
21666 /* Fill glyph string S from a sequence of character glyphs.
21668 FACE_ID is the face id of the string. START is the index of the
21669 first glyph to consider, END is the index of the last + 1.
21670 OVERLAPS non-zero means S should draw the foreground only, and use
21671 its physical height for clipping. See also draw_glyphs.
21673 Value is the index of the first glyph not in S. */
21676 fill_glyph_string (struct glyph_string
*s
, int face_id
,
21677 int start
, int end
, int overlaps
)
21679 struct glyph
*glyph
, *last
;
21681 int glyph_not_available_p
;
21683 xassert (s
->f
== XFRAME (s
->w
->frame
));
21684 xassert (s
->nchars
== 0);
21685 xassert (start
>= 0 && end
> start
);
21687 s
->for_overlaps
= overlaps
;
21688 glyph
= s
->row
->glyphs
[s
->area
] + start
;
21689 last
= s
->row
->glyphs
[s
->area
] + end
;
21690 voffset
= glyph
->voffset
;
21691 s
->padding_p
= glyph
->padding_p
;
21692 glyph_not_available_p
= glyph
->glyph_not_available_p
;
21694 while (glyph
< last
21695 && glyph
->type
== CHAR_GLYPH
21696 && glyph
->voffset
== voffset
21697 /* Same face id implies same font, nowadays. */
21698 && glyph
->face_id
== face_id
21699 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
21703 s
->face
= get_glyph_face_and_encoding (s
->f
, glyph
,
21704 s
->char2b
+ s
->nchars
,
21706 s
->two_byte_p
= two_byte_p
;
21708 xassert (s
->nchars
<= end
- start
);
21709 s
->width
+= glyph
->pixel_width
;
21710 if (glyph
++->padding_p
!= s
->padding_p
)
21714 s
->font
= s
->face
->font
;
21716 /* If the specified font could not be loaded, use the frame's font,
21717 but record the fact that we couldn't load it in
21718 S->font_not_found_p so that we can draw rectangles for the
21719 characters of the glyph string. */
21720 if (s
->font
== NULL
|| glyph_not_available_p
)
21722 s
->font_not_found_p
= 1;
21723 s
->font
= FRAME_FONT (s
->f
);
21726 /* Adjust base line for subscript/superscript text. */
21727 s
->ybase
+= voffset
;
21729 xassert (s
->face
&& s
->face
->gc
);
21730 return glyph
- s
->row
->glyphs
[s
->area
];
21734 /* Fill glyph string S from image glyph S->first_glyph. */
21737 fill_image_glyph_string (struct glyph_string
*s
)
21739 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
21740 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
21742 s
->slice
= s
->first_glyph
->slice
.img
;
21743 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
21744 s
->font
= s
->face
->font
;
21745 s
->width
= s
->first_glyph
->pixel_width
;
21747 /* Adjust base line for subscript/superscript text. */
21748 s
->ybase
+= s
->first_glyph
->voffset
;
21752 /* Fill glyph string S from a sequence of stretch glyphs.
21754 START is the index of the first glyph to consider,
21755 END is the index of the last + 1.
21757 Value is the index of the first glyph not in S. */
21760 fill_stretch_glyph_string (struct glyph_string
*s
, int start
, int end
)
21762 struct glyph
*glyph
, *last
;
21763 int voffset
, face_id
;
21765 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
21767 glyph
= s
->row
->glyphs
[s
->area
] + start
;
21768 last
= s
->row
->glyphs
[s
->area
] + end
;
21769 face_id
= glyph
->face_id
;
21770 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
21771 s
->font
= s
->face
->font
;
21772 s
->width
= glyph
->pixel_width
;
21774 voffset
= glyph
->voffset
;
21778 && glyph
->type
== STRETCH_GLYPH
21779 && glyph
->voffset
== voffset
21780 && glyph
->face_id
== face_id
);
21782 s
->width
+= glyph
->pixel_width
;
21784 /* Adjust base line for subscript/superscript text. */
21785 s
->ybase
+= voffset
;
21787 /* The case that face->gc == 0 is handled when drawing the glyph
21788 string by calling PREPARE_FACE_FOR_DISPLAY. */
21790 return glyph
- s
->row
->glyphs
[s
->area
];
21793 static struct font_metrics
*
21794 get_per_char_metric (struct font
*font
, XChar2b
*char2b
)
21796 static struct font_metrics metrics
;
21797 unsigned code
= (XCHAR2B_BYTE1 (char2b
) << 8) | XCHAR2B_BYTE2 (char2b
);
21799 if (! font
|| code
== FONT_INVALID_CODE
)
21801 font
->driver
->text_extents (font
, &code
, 1, &metrics
);
21806 Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
21807 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
21808 assumed to be zero. */
21811 x_get_glyph_overhangs (struct glyph
*glyph
, struct frame
*f
, int *left
, int *right
)
21813 *left
= *right
= 0;
21815 if (glyph
->type
== CHAR_GLYPH
)
21819 struct font_metrics
*pcm
;
21821 face
= get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
21822 if (face
->font
&& (pcm
= get_per_char_metric (face
->font
, &char2b
)))
21824 if (pcm
->rbearing
> pcm
->width
)
21825 *right
= pcm
->rbearing
- pcm
->width
;
21826 if (pcm
->lbearing
< 0)
21827 *left
= -pcm
->lbearing
;
21830 else if (glyph
->type
== COMPOSITE_GLYPH
)
21832 if (! glyph
->u
.cmp
.automatic
)
21834 struct composition
*cmp
= composition_table
[glyph
->u
.cmp
.id
];
21836 if (cmp
->rbearing
> cmp
->pixel_width
)
21837 *right
= cmp
->rbearing
- cmp
->pixel_width
;
21838 if (cmp
->lbearing
< 0)
21839 *left
= - cmp
->lbearing
;
21843 Lisp_Object gstring
= composition_gstring_from_id (glyph
->u
.cmp
.id
);
21844 struct font_metrics metrics
;
21846 composition_gstring_width (gstring
, glyph
->slice
.cmp
.from
,
21847 glyph
->slice
.cmp
.to
+ 1, &metrics
);
21848 if (metrics
.rbearing
> metrics
.width
)
21849 *right
= metrics
.rbearing
- metrics
.width
;
21850 if (metrics
.lbearing
< 0)
21851 *left
= - metrics
.lbearing
;
21857 /* Return the index of the first glyph preceding glyph string S that
21858 is overwritten by S because of S's left overhang. Value is -1
21859 if no glyphs are overwritten. */
21862 left_overwritten (struct glyph_string
*s
)
21866 if (s
->left_overhang
)
21869 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21870 int first
= s
->first_glyph
- glyphs
;
21872 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
21873 x
-= glyphs
[i
].pixel_width
;
21884 /* Return the index of the first glyph preceding glyph string S that
21885 is overwriting S because of its right overhang. Value is -1 if no
21886 glyph in front of S overwrites S. */
21889 left_overwriting (struct glyph_string
*s
)
21892 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21893 int first
= s
->first_glyph
- glyphs
;
21897 for (i
= first
- 1; i
>= 0; --i
)
21900 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
21903 x
-= glyphs
[i
].pixel_width
;
21910 /* Return the index of the last glyph following glyph string S that is
21911 overwritten by S because of S's right overhang. Value is -1 if
21912 no such glyph is found. */
21915 right_overwritten (struct glyph_string
*s
)
21919 if (s
->right_overhang
)
21922 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21923 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
21924 int end
= s
->row
->used
[s
->area
];
21926 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
21927 x
+= glyphs
[i
].pixel_width
;
21936 /* Return the index of the last glyph following glyph string S that
21937 overwrites S because of its left overhang. Value is negative
21938 if no such glyph is found. */
21941 right_overwriting (struct glyph_string
*s
)
21944 int end
= s
->row
->used
[s
->area
];
21945 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
21946 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
21950 for (i
= first
; i
< end
; ++i
)
21953 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
21956 x
+= glyphs
[i
].pixel_width
;
21963 /* Set background width of glyph string S. START is the index of the
21964 first glyph following S. LAST_X is the right-most x-position + 1
21965 in the drawing area. */
21968 set_glyph_string_background_width (struct glyph_string
*s
, int start
, int last_x
)
21970 /* If the face of this glyph string has to be drawn to the end of
21971 the drawing area, set S->extends_to_end_of_line_p. */
21973 if (start
== s
->row
->used
[s
->area
]
21974 && s
->area
== TEXT_AREA
21975 && ((s
->row
->fill_line_p
21976 && (s
->hl
== DRAW_NORMAL_TEXT
21977 || s
->hl
== DRAW_IMAGE_RAISED
21978 || s
->hl
== DRAW_IMAGE_SUNKEN
))
21979 || s
->hl
== DRAW_MOUSE_FACE
))
21980 s
->extends_to_end_of_line_p
= 1;
21982 /* If S extends its face to the end of the line, set its
21983 background_width to the distance to the right edge of the drawing
21985 if (s
->extends_to_end_of_line_p
)
21986 s
->background_width
= last_x
- s
->x
+ 1;
21988 s
->background_width
= s
->width
;
21992 /* Compute overhangs and x-positions for glyph string S and its
21993 predecessors, or successors. X is the starting x-position for S.
21994 BACKWARD_P non-zero means process predecessors. */
21997 compute_overhangs_and_x (struct glyph_string
*s
, int x
, int backward_p
)
22003 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
22004 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
22014 if (FRAME_RIF (s
->f
)->compute_glyph_string_overhangs
)
22015 FRAME_RIF (s
->f
)->compute_glyph_string_overhangs (s
);
22025 /* The following macros are only called from draw_glyphs below.
22026 They reference the following parameters of that function directly:
22027 `w', `row', `area', and `overlap_p'
22028 as well as the following local variables:
22029 `s', `f', and `hdc' (in W32) */
22032 /* On W32, silently add local `hdc' variable to argument list of
22033 init_glyph_string. */
22034 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
22035 init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
22037 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
22038 init_glyph_string (s, char2b, w, row, area, start, hl)
22041 /* Add a glyph string for a stretch glyph to the list of strings
22042 between HEAD and TAIL. START is the index of the stretch glyph in
22043 row area AREA of glyph row ROW. END is the index of the last glyph
22044 in that glyph row area. X is the current output position assigned
22045 to the new glyph string constructed. HL overrides that face of the
22046 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
22047 is the right-most x-position of the drawing area. */
22049 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
22050 and below -- keep them on one line. */
22051 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22054 s = (struct glyph_string *) alloca (sizeof *s); \
22055 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22056 START = fill_stretch_glyph_string (s, START, END); \
22057 append_glyph_string (&HEAD, &TAIL, s); \
22063 /* Add a glyph string for an image glyph to the list of strings
22064 between HEAD and TAIL. START is the index of the image glyph in
22065 row area AREA of glyph row ROW. END is the index of the last glyph
22066 in that glyph row area. X is the current output position assigned
22067 to the new glyph string constructed. HL overrides that face of the
22068 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
22069 is the right-most x-position of the drawing area. */
22071 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22074 s = (struct glyph_string *) alloca (sizeof *s); \
22075 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22076 fill_image_glyph_string (s); \
22077 append_glyph_string (&HEAD, &TAIL, s); \
22084 /* Add a glyph string for a sequence of character glyphs to the list
22085 of strings between HEAD and TAIL. START is the index of the first
22086 glyph in row area AREA of glyph row ROW that is part of the new
22087 glyph string. END is the index of the last glyph in that glyph row
22088 area. X is the current output position assigned to the new glyph
22089 string constructed. HL overrides that face of the glyph; e.g. it
22090 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
22091 right-most x-position of the drawing area. */
22093 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
22099 face_id = (row)->glyphs[area][START].face_id; \
22101 s = (struct glyph_string *) alloca (sizeof *s); \
22102 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
22103 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22104 append_glyph_string (&HEAD, &TAIL, s); \
22106 START = fill_glyph_string (s, face_id, START, END, overlaps); \
22111 /* Add a glyph string for a composite sequence to the list of strings
22112 between HEAD and TAIL. START is the index of the first glyph in
22113 row area AREA of glyph row ROW that is part of the new glyph
22114 string. END is the index of the last glyph in that glyph row area.
22115 X is the current output position assigned to the new glyph string
22116 constructed. HL overrides that face of the glyph; e.g. it is
22117 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
22118 x-position of the drawing area. */
22120 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22122 int face_id = (row)->glyphs[area][START].face_id; \
22123 struct face *base_face = FACE_FROM_ID (f, face_id); \
22124 int cmp_id = (row)->glyphs[area][START].u.cmp.id; \
22125 struct composition *cmp = composition_table[cmp_id]; \
22127 struct glyph_string *first_s IF_LINT (= NULL); \
22130 char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len); \
22132 /* Make glyph_strings for each glyph sequence that is drawable by \
22133 the same face, and append them to HEAD/TAIL. */ \
22134 for (n = 0; n < cmp->glyph_len;) \
22136 s = (struct glyph_string *) alloca (sizeof *s); \
22137 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22138 append_glyph_string (&(HEAD), &(TAIL), s); \
22144 n = fill_composite_glyph_string (s, base_face, overlaps); \
22152 /* Add a glyph string for a glyph-string sequence to the list of strings
22153 between HEAD and TAIL. */
22155 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22159 Lisp_Object gstring; \
22161 face_id = (row)->glyphs[area][START].face_id; \
22162 gstring = (composition_gstring_from_id \
22163 ((row)->glyphs[area][START].u.cmp.id)); \
22164 s = (struct glyph_string *) alloca (sizeof *s); \
22165 char2b = (XChar2b *) alloca ((sizeof *char2b) \
22166 * LGSTRING_GLYPH_LEN (gstring)); \
22167 INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL); \
22168 append_glyph_string (&(HEAD), &(TAIL), s); \
22170 START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
22174 /* Add a glyph string for a sequence of glyphless character's glyphs
22175 to the list of strings between HEAD and TAIL. The meanings of
22176 arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS. */
22178 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
22183 face_id = (row)->glyphs[area][START].face_id; \
22185 s = (struct glyph_string *) alloca (sizeof *s); \
22186 INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
22187 append_glyph_string (&HEAD, &TAIL, s); \
22189 START = fill_glyphless_glyph_string (s, face_id, START, END, \
22195 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
22196 of AREA of glyph row ROW on window W between indices START and END.
22197 HL overrides the face for drawing glyph strings, e.g. it is
22198 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
22199 x-positions of the drawing area.
22201 This is an ugly monster macro construct because we must use alloca
22202 to allocate glyph strings (because draw_glyphs can be called
22203 asynchronously). */
22205 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
22208 HEAD = TAIL = NULL; \
22209 while (START < END) \
22211 struct glyph *first_glyph = (row)->glyphs[area] + START; \
22212 switch (first_glyph->type) \
22215 BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL, \
22219 case COMPOSITE_GLYPH: \
22220 if (first_glyph->u.cmp.automatic) \
22221 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL, \
22224 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL, \
22228 case STRETCH_GLYPH: \
22229 BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL, \
22233 case IMAGE_GLYPH: \
22234 BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
22238 case GLYPHLESS_GLYPH: \
22239 BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
22249 set_glyph_string_background_width (s, START, LAST_X); \
22256 /* Draw glyphs between START and END in AREA of ROW on window W,
22257 starting at x-position X. X is relative to AREA in W. HL is a
22258 face-override with the following meaning:
22260 DRAW_NORMAL_TEXT draw normally
22261 DRAW_CURSOR draw in cursor face
22262 DRAW_MOUSE_FACE draw in mouse face.
22263 DRAW_INVERSE_VIDEO draw in mode line face
22264 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
22265 DRAW_IMAGE_RAISED draw an image with a raised relief around it
22267 If OVERLAPS is non-zero, draw only the foreground of characters and
22268 clip to the physical height of ROW. Non-zero value also defines
22269 the overlapping part to be drawn:
22271 OVERLAPS_PRED overlap with preceding rows
22272 OVERLAPS_SUCC overlap with succeeding rows
22273 OVERLAPS_BOTH overlap with both preceding/succeeding rows
22274 OVERLAPS_ERASED_CURSOR overlap with erased cursor area
22276 Value is the x-position reached, relative to AREA of W. */
22279 draw_glyphs (struct window
*w
, int x
, struct glyph_row
*row
,
22280 enum glyph_row_area area
, EMACS_INT start
, EMACS_INT end
,
22281 enum draw_glyphs_face hl
, int overlaps
)
22283 struct glyph_string
*head
, *tail
;
22284 struct glyph_string
*s
;
22285 struct glyph_string
*clip_head
= NULL
, *clip_tail
= NULL
;
22286 int i
, j
, x_reached
, last_x
, area_left
= 0;
22287 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
22290 ALLOCATE_HDC (hdc
, f
);
22292 /* Let's rather be paranoid than getting a SEGV. */
22293 end
= min (end
, row
->used
[area
]);
22294 start
= max (0, start
);
22295 start
= min (end
, start
);
22297 /* Translate X to frame coordinates. Set last_x to the right
22298 end of the drawing area. */
22299 if (row
->full_width_p
)
22301 /* X is relative to the left edge of W, without scroll bars
22303 area_left
= WINDOW_LEFT_EDGE_X (w
);
22304 last_x
= WINDOW_LEFT_EDGE_X (w
) + WINDOW_TOTAL_WIDTH (w
);
22308 area_left
= window_box_left (w
, area
);
22309 last_x
= area_left
+ window_box_width (w
, area
);
22313 /* Build a doubly-linked list of glyph_string structures between
22314 head and tail from what we have to draw. Note that the macro
22315 BUILD_GLYPH_STRINGS will modify its start parameter. That's
22316 the reason we use a separate variable `i'. */
22318 BUILD_GLYPH_STRINGS (i
, end
, head
, tail
, hl
, x
, last_x
);
22320 x_reached
= tail
->x
+ tail
->background_width
;
22324 /* If there are any glyphs with lbearing < 0 or rbearing > width in
22325 the row, redraw some glyphs in front or following the glyph
22326 strings built above. */
22327 if (head
&& !overlaps
&& row
->contains_overlapping_glyphs_p
)
22329 struct glyph_string
*h
, *t
;
22330 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
22331 int mouse_beg_col
IF_LINT (= 0), mouse_end_col
IF_LINT (= 0);
22332 int check_mouse_face
= 0;
22335 /* If mouse highlighting is on, we may need to draw adjacent
22336 glyphs using mouse-face highlighting. */
22337 if (area
== TEXT_AREA
&& row
->mouse_face_p
)
22339 struct glyph_row
*mouse_beg_row
, *mouse_end_row
;
22341 mouse_beg_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
22342 mouse_end_row
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
22344 if (row
>= mouse_beg_row
&& row
<= mouse_end_row
)
22346 check_mouse_face
= 1;
22347 mouse_beg_col
= (row
== mouse_beg_row
)
22348 ? hlinfo
->mouse_face_beg_col
: 0;
22349 mouse_end_col
= (row
== mouse_end_row
)
22350 ? hlinfo
->mouse_face_end_col
22351 : row
->used
[TEXT_AREA
];
22355 /* Compute overhangs for all glyph strings. */
22356 if (FRAME_RIF (f
)->compute_glyph_string_overhangs
)
22357 for (s
= head
; s
; s
= s
->next
)
22358 FRAME_RIF (f
)->compute_glyph_string_overhangs (s
);
22360 /* Prepend glyph strings for glyphs in front of the first glyph
22361 string that are overwritten because of the first glyph
22362 string's left overhang. The background of all strings
22363 prepended must be drawn because the first glyph string
22365 i
= left_overwritten (head
);
22368 enum draw_glyphs_face overlap_hl
;
22370 /* If this row contains mouse highlighting, attempt to draw
22371 the overlapped glyphs with the correct highlight. This
22372 code fails if the overlap encompasses more than one glyph
22373 and mouse-highlight spans only some of these glyphs.
22374 However, making it work perfectly involves a lot more
22375 code, and I don't know if the pathological case occurs in
22376 practice, so we'll stick to this for now. --- cyd */
22377 if (check_mouse_face
22378 && mouse_beg_col
< start
&& mouse_end_col
> i
)
22379 overlap_hl
= DRAW_MOUSE_FACE
;
22381 overlap_hl
= DRAW_NORMAL_TEXT
;
22384 BUILD_GLYPH_STRINGS (j
, start
, h
, t
,
22385 overlap_hl
, dummy_x
, last_x
);
22387 compute_overhangs_and_x (t
, head
->x
, 1);
22388 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
22392 /* Prepend glyph strings for glyphs in front of the first glyph
22393 string that overwrite that glyph string because of their
22394 right overhang. For these strings, only the foreground must
22395 be drawn, because it draws over the glyph string at `head'.
22396 The background must not be drawn because this would overwrite
22397 right overhangs of preceding glyphs for which no glyph
22399 i
= left_overwriting (head
);
22402 enum draw_glyphs_face overlap_hl
;
22404 if (check_mouse_face
22405 && mouse_beg_col
< start
&& mouse_end_col
> i
)
22406 overlap_hl
= DRAW_MOUSE_FACE
;
22408 overlap_hl
= DRAW_NORMAL_TEXT
;
22411 BUILD_GLYPH_STRINGS (i
, start
, h
, t
,
22412 overlap_hl
, dummy_x
, last_x
);
22413 for (s
= h
; s
; s
= s
->next
)
22414 s
->background_filled_p
= 1;
22415 compute_overhangs_and_x (t
, head
->x
, 1);
22416 prepend_glyph_string_lists (&head
, &tail
, h
, t
);
22419 /* Append glyphs strings for glyphs following the last glyph
22420 string tail that are overwritten by tail. The background of
22421 these strings has to be drawn because tail's foreground draws
22423 i
= right_overwritten (tail
);
22426 enum draw_glyphs_face overlap_hl
;
22428 if (check_mouse_face
22429 && mouse_beg_col
< i
&& mouse_end_col
> end
)
22430 overlap_hl
= DRAW_MOUSE_FACE
;
22432 overlap_hl
= DRAW_NORMAL_TEXT
;
22434 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
22435 overlap_hl
, x
, last_x
);
22436 /* Because BUILD_GLYPH_STRINGS updates the first argument,
22437 we don't have `end = i;' here. */
22438 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
22439 append_glyph_string_lists (&head
, &tail
, h
, t
);
22443 /* Append glyph strings for glyphs following the last glyph
22444 string tail that overwrite tail. The foreground of such
22445 glyphs has to be drawn because it writes into the background
22446 of tail. The background must not be drawn because it could
22447 paint over the foreground of following glyphs. */
22448 i
= right_overwriting (tail
);
22451 enum draw_glyphs_face overlap_hl
;
22452 if (check_mouse_face
22453 && mouse_beg_col
< i
&& mouse_end_col
> end
)
22454 overlap_hl
= DRAW_MOUSE_FACE
;
22456 overlap_hl
= DRAW_NORMAL_TEXT
;
22459 i
++; /* We must include the Ith glyph. */
22460 BUILD_GLYPH_STRINGS (end
, i
, h
, t
,
22461 overlap_hl
, x
, last_x
);
22462 for (s
= h
; s
; s
= s
->next
)
22463 s
->background_filled_p
= 1;
22464 compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
22465 append_glyph_string_lists (&head
, &tail
, h
, t
);
22467 if (clip_head
|| clip_tail
)
22468 for (s
= head
; s
; s
= s
->next
)
22470 s
->clip_head
= clip_head
;
22471 s
->clip_tail
= clip_tail
;
22475 /* Draw all strings. */
22476 for (s
= head
; s
; s
= s
->next
)
22477 FRAME_RIF (f
)->draw_glyph_string (s
);
22480 /* When focus a sole frame and move horizontally, this sets on_p to 0
22481 causing a failure to erase prev cursor position. */
22482 if (area
== TEXT_AREA
22483 && !row
->full_width_p
22484 /* When drawing overlapping rows, only the glyph strings'
22485 foreground is drawn, which doesn't erase a cursor
22489 int x0
= clip_head
? clip_head
->x
: (head
? head
->x
: x
);
22490 int x1
= (clip_tail
? clip_tail
->x
+ clip_tail
->background_width
22491 : (tail
? tail
->x
+ tail
->background_width
: x
));
22495 notice_overwritten_cursor (w
, TEXT_AREA
, x0
, x1
,
22496 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
22500 /* Value is the x-position up to which drawn, relative to AREA of W.
22501 This doesn't include parts drawn because of overhangs. */
22502 if (row
->full_width_p
)
22503 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
22505 x_reached
-= area_left
;
22507 RELEASE_HDC (hdc
, f
);
22512 /* Expand row matrix if too narrow. Don't expand if area
22515 #define IT_EXPAND_MATRIX_WIDTH(it, area) \
22517 if (!fonts_changed_p \
22518 && (it->glyph_row->glyphs[area] \
22519 < it->glyph_row->glyphs[area + 1])) \
22521 it->w->ncols_scale_factor++; \
22522 fonts_changed_p = 1; \
22526 /* Store one glyph for IT->char_to_display in IT->glyph_row.
22527 Called from x_produce_glyphs when IT->glyph_row is non-null. */
22530 append_glyph (struct it
*it
)
22532 struct glyph
*glyph
;
22533 enum glyph_row_area area
= it
->area
;
22535 xassert (it
->glyph_row
);
22536 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
22538 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22539 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22541 /* If the glyph row is reversed, we need to prepend the glyph
22542 rather than append it. */
22543 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
22547 /* Make room for the additional glyph. */
22548 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
22550 glyph
= it
->glyph_row
->glyphs
[area
];
22552 glyph
->charpos
= CHARPOS (it
->position
);
22553 glyph
->object
= it
->object
;
22554 if (it
->pixel_width
> 0)
22556 glyph
->pixel_width
= it
->pixel_width
;
22557 glyph
->padding_p
= 0;
22561 /* Assure at least 1-pixel width. Otherwise, cursor can't
22562 be displayed correctly. */
22563 glyph
->pixel_width
= 1;
22564 glyph
->padding_p
= 1;
22566 glyph
->ascent
= it
->ascent
;
22567 glyph
->descent
= it
->descent
;
22568 glyph
->voffset
= it
->voffset
;
22569 glyph
->type
= CHAR_GLYPH
;
22570 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22571 glyph
->multibyte_p
= it
->multibyte_p
;
22572 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22573 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22574 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
22575 || it
->phys_descent
> it
->descent
);
22576 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
22577 glyph
->face_id
= it
->face_id
;
22578 glyph
->u
.ch
= it
->char_to_display
;
22579 glyph
->slice
.img
= null_glyph_slice
;
22580 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22583 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22584 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22586 glyph
->bidi_type
= it
->bidi_it
.type
;
22590 glyph
->resolved_level
= 0;
22591 glyph
->bidi_type
= UNKNOWN_BT
;
22593 ++it
->glyph_row
->used
[area
];
22596 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22599 /* Store one glyph for the composition IT->cmp_it.id in
22600 IT->glyph_row. Called from x_produce_glyphs when IT->glyph_row is
22604 append_composite_glyph (struct it
*it
)
22606 struct glyph
*glyph
;
22607 enum glyph_row_area area
= it
->area
;
22609 xassert (it
->glyph_row
);
22611 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22612 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22614 /* If the glyph row is reversed, we need to prepend the glyph
22615 rather than append it. */
22616 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
22620 /* Make room for the new glyph. */
22621 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
22623 glyph
= it
->glyph_row
->glyphs
[it
->area
];
22625 glyph
->charpos
= it
->cmp_it
.charpos
;
22626 glyph
->object
= it
->object
;
22627 glyph
->pixel_width
= it
->pixel_width
;
22628 glyph
->ascent
= it
->ascent
;
22629 glyph
->descent
= it
->descent
;
22630 glyph
->voffset
= it
->voffset
;
22631 glyph
->type
= COMPOSITE_GLYPH
;
22632 if (it
->cmp_it
.ch
< 0)
22634 glyph
->u
.cmp
.automatic
= 0;
22635 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
22636 glyph
->slice
.cmp
.from
= glyph
->slice
.cmp
.to
= 0;
22640 glyph
->u
.cmp
.automatic
= 1;
22641 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
22642 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
22643 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
22645 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22646 glyph
->multibyte_p
= it
->multibyte_p
;
22647 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22648 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22649 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
22650 || it
->phys_descent
> it
->descent
);
22651 glyph
->padding_p
= 0;
22652 glyph
->glyph_not_available_p
= 0;
22653 glyph
->face_id
= it
->face_id
;
22654 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22657 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22658 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22660 glyph
->bidi_type
= it
->bidi_it
.type
;
22662 ++it
->glyph_row
->used
[area
];
22665 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22669 /* Change IT->ascent and IT->height according to the setting of
22673 take_vertical_position_into_account (struct it
*it
)
22677 if (it
->voffset
< 0)
22678 /* Increase the ascent so that we can display the text higher
22680 it
->ascent
-= it
->voffset
;
22682 /* Increase the descent so that we can display the text lower
22684 it
->descent
+= it
->voffset
;
22689 /* Produce glyphs/get display metrics for the image IT is loaded with.
22690 See the description of struct display_iterator in dispextern.h for
22691 an overview of struct display_iterator. */
22694 produce_image_glyph (struct it
*it
)
22698 int glyph_ascent
, crop
;
22699 struct glyph_slice slice
;
22701 xassert (it
->what
== IT_IMAGE
);
22703 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
22705 /* Make sure X resources of the face is loaded. */
22706 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
22708 if (it
->image_id
< 0)
22710 /* Fringe bitmap. */
22711 it
->ascent
= it
->phys_ascent
= 0;
22712 it
->descent
= it
->phys_descent
= 0;
22713 it
->pixel_width
= 0;
22718 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
22720 /* Make sure X resources of the image is loaded. */
22721 prepare_image_for_display (it
->f
, img
);
22723 slice
.x
= slice
.y
= 0;
22724 slice
.width
= img
->width
;
22725 slice
.height
= img
->height
;
22727 if (INTEGERP (it
->slice
.x
))
22728 slice
.x
= XINT (it
->slice
.x
);
22729 else if (FLOATP (it
->slice
.x
))
22730 slice
.x
= XFLOAT_DATA (it
->slice
.x
) * img
->width
;
22732 if (INTEGERP (it
->slice
.y
))
22733 slice
.y
= XINT (it
->slice
.y
);
22734 else if (FLOATP (it
->slice
.y
))
22735 slice
.y
= XFLOAT_DATA (it
->slice
.y
) * img
->height
;
22737 if (INTEGERP (it
->slice
.width
))
22738 slice
.width
= XINT (it
->slice
.width
);
22739 else if (FLOATP (it
->slice
.width
))
22740 slice
.width
= XFLOAT_DATA (it
->slice
.width
) * img
->width
;
22742 if (INTEGERP (it
->slice
.height
))
22743 slice
.height
= XINT (it
->slice
.height
);
22744 else if (FLOATP (it
->slice
.height
))
22745 slice
.height
= XFLOAT_DATA (it
->slice
.height
) * img
->height
;
22747 if (slice
.x
>= img
->width
)
22748 slice
.x
= img
->width
;
22749 if (slice
.y
>= img
->height
)
22750 slice
.y
= img
->height
;
22751 if (slice
.x
+ slice
.width
>= img
->width
)
22752 slice
.width
= img
->width
- slice
.x
;
22753 if (slice
.y
+ slice
.height
> img
->height
)
22754 slice
.height
= img
->height
- slice
.y
;
22756 if (slice
.width
== 0 || slice
.height
== 0)
22759 it
->ascent
= it
->phys_ascent
= glyph_ascent
= image_ascent (img
, face
, &slice
);
22761 it
->descent
= slice
.height
- glyph_ascent
;
22763 it
->descent
+= img
->vmargin
;
22764 if (slice
.y
+ slice
.height
== img
->height
)
22765 it
->descent
+= img
->vmargin
;
22766 it
->phys_descent
= it
->descent
;
22768 it
->pixel_width
= slice
.width
;
22770 it
->pixel_width
+= img
->hmargin
;
22771 if (slice
.x
+ slice
.width
== img
->width
)
22772 it
->pixel_width
+= img
->hmargin
;
22774 /* It's quite possible for images to have an ascent greater than
22775 their height, so don't get confused in that case. */
22776 if (it
->descent
< 0)
22781 if (face
->box
!= FACE_NO_BOX
)
22783 if (face
->box_line_width
> 0)
22786 it
->ascent
+= face
->box_line_width
;
22787 if (slice
.y
+ slice
.height
== img
->height
)
22788 it
->descent
+= face
->box_line_width
;
22791 if (it
->start_of_box_run_p
&& slice
.x
== 0)
22792 it
->pixel_width
+= eabs (face
->box_line_width
);
22793 if (it
->end_of_box_run_p
&& slice
.x
+ slice
.width
== img
->width
)
22794 it
->pixel_width
+= eabs (face
->box_line_width
);
22797 take_vertical_position_into_account (it
);
22799 /* Automatically crop wide image glyphs at right edge so we can
22800 draw the cursor on same display row. */
22801 if ((crop
= it
->pixel_width
- (it
->last_visible_x
- it
->current_x
), crop
> 0)
22802 && (it
->hpos
== 0 || it
->pixel_width
> it
->last_visible_x
/ 4))
22804 it
->pixel_width
-= crop
;
22805 slice
.width
-= crop
;
22810 struct glyph
*glyph
;
22811 enum glyph_row_area area
= it
->area
;
22813 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22814 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22816 glyph
->charpos
= CHARPOS (it
->position
);
22817 glyph
->object
= it
->object
;
22818 glyph
->pixel_width
= it
->pixel_width
;
22819 glyph
->ascent
= glyph_ascent
;
22820 glyph
->descent
= it
->descent
;
22821 glyph
->voffset
= it
->voffset
;
22822 glyph
->type
= IMAGE_GLYPH
;
22823 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22824 glyph
->multibyte_p
= it
->multibyte_p
;
22825 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22826 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22827 glyph
->overlaps_vertically_p
= 0;
22828 glyph
->padding_p
= 0;
22829 glyph
->glyph_not_available_p
= 0;
22830 glyph
->face_id
= it
->face_id
;
22831 glyph
->u
.img_id
= img
->id
;
22832 glyph
->slice
.img
= slice
;
22833 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22836 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22837 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22839 glyph
->bidi_type
= it
->bidi_it
.type
;
22841 ++it
->glyph_row
->used
[area
];
22844 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22849 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
22850 of the glyph, WIDTH and HEIGHT are the width and height of the
22851 stretch. ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT). */
22854 append_stretch_glyph (struct it
*it
, Lisp_Object object
,
22855 int width
, int height
, int ascent
)
22857 struct glyph
*glyph
;
22858 enum glyph_row_area area
= it
->area
;
22860 xassert (ascent
>= 0 && ascent
<= height
);
22862 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
22863 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
22865 /* If the glyph row is reversed, we need to prepend the glyph
22866 rather than append it. */
22867 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
22871 /* Make room for the additional glyph. */
22872 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
22874 glyph
= it
->glyph_row
->glyphs
[area
];
22876 glyph
->charpos
= CHARPOS (it
->position
);
22877 glyph
->object
= object
;
22878 glyph
->pixel_width
= width
;
22879 glyph
->ascent
= ascent
;
22880 glyph
->descent
= height
- ascent
;
22881 glyph
->voffset
= it
->voffset
;
22882 glyph
->type
= STRETCH_GLYPH
;
22883 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
22884 glyph
->multibyte_p
= it
->multibyte_p
;
22885 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
22886 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
22887 glyph
->overlaps_vertically_p
= 0;
22888 glyph
->padding_p
= 0;
22889 glyph
->glyph_not_available_p
= 0;
22890 glyph
->face_id
= it
->face_id
;
22891 glyph
->u
.stretch
.ascent
= ascent
;
22892 glyph
->u
.stretch
.height
= height
;
22893 glyph
->slice
.img
= null_glyph_slice
;
22894 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
22897 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
22898 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
22900 glyph
->bidi_type
= it
->bidi_it
.type
;
22904 glyph
->resolved_level
= 0;
22905 glyph
->bidi_type
= UNKNOWN_BT
;
22907 ++it
->glyph_row
->used
[area
];
22910 IT_EXPAND_MATRIX_WIDTH (it
, area
);
22914 /* Produce a stretch glyph for iterator IT. IT->object is the value
22915 of the glyph property displayed. The value must be a list
22916 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
22919 1. `:width WIDTH' specifies that the space should be WIDTH *
22920 canonical char width wide. WIDTH may be an integer or floating
22923 2. `:relative-width FACTOR' specifies that the width of the stretch
22924 should be computed from the width of the first character having the
22925 `glyph' property, and should be FACTOR times that width.
22927 3. `:align-to HPOS' specifies that the space should be wide enough
22928 to reach HPOS, a value in canonical character units.
22930 Exactly one of the above pairs must be present.
22932 4. `:height HEIGHT' specifies that the height of the stretch produced
22933 should be HEIGHT, measured in canonical character units.
22935 5. `:relative-height FACTOR' specifies that the height of the
22936 stretch should be FACTOR times the height of the characters having
22937 the glyph property.
22939 Either none or exactly one of 4 or 5 must be present.
22941 6. `:ascent ASCENT' specifies that ASCENT percent of the height
22942 of the stretch should be used for the ascent of the stretch.
22943 ASCENT must be in the range 0 <= ASCENT <= 100. */
22946 produce_stretch_glyph (struct it
*it
)
22948 /* (space :width WIDTH :height HEIGHT ...) */
22949 Lisp_Object prop
, plist
;
22950 int width
= 0, height
= 0, align_to
= -1;
22951 int zero_width_ok_p
= 0, zero_height_ok_p
= 0;
22954 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
22955 struct font
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
22957 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
22959 /* List should start with `space'. */
22960 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
22961 plist
= XCDR (it
->object
);
22963 /* Compute the width of the stretch. */
22964 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
22965 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, 0))
22967 /* Absolute width `:width WIDTH' specified and valid. */
22968 zero_width_ok_p
= 1;
22971 else if (prop
= Fplist_get (plist
, QCrelative_width
),
22974 /* Relative width `:relative-width FACTOR' specified and valid.
22975 Compute the width of the characters having the `glyph'
22978 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
22981 if (it
->multibyte_p
)
22982 it2
.c
= it2
.char_to_display
= STRING_CHAR_AND_LENGTH (p
, it2
.len
);
22985 it2
.c
= it2
.char_to_display
= *p
, it2
.len
= 1;
22986 if (! ASCII_CHAR_P (it2
.c
))
22987 it2
.char_to_display
= BYTE8_TO_CHAR (it2
.c
);
22990 it2
.glyph_row
= NULL
;
22991 it2
.what
= IT_CHARACTER
;
22992 x_produce_glyphs (&it2
);
22993 width
= NUMVAL (prop
) * it2
.pixel_width
;
22995 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
22996 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 1, &align_to
))
22998 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
22999 align_to
= (align_to
< 0
23001 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
23002 else if (align_to
< 0)
23003 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
23004 width
= max (0, (int)tem
+ align_to
- it
->current_x
);
23005 zero_width_ok_p
= 1;
23008 /* Nothing specified -> width defaults to canonical char width. */
23009 width
= FRAME_COLUMN_WIDTH (it
->f
);
23011 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
23014 /* Compute height. */
23015 if ((prop
= Fplist_get (plist
, QCheight
), !NILP (prop
))
23016 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
23019 zero_height_ok_p
= 1;
23021 else if (prop
= Fplist_get (plist
, QCrelative_height
),
23023 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
23025 height
= FONT_HEIGHT (font
);
23027 if (height
<= 0 && (height
< 0 || !zero_height_ok_p
))
23030 /* Compute percentage of height used for ascent. If
23031 `:ascent ASCENT' is present and valid, use that. Otherwise,
23032 derive the ascent from the font in use. */
23033 if (prop
= Fplist_get (plist
, QCascent
),
23034 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
23035 ascent
= height
* NUMVAL (prop
) / 100.0;
23036 else if (!NILP (prop
)
23037 && calc_pixel_width_or_height (&tem
, it
, prop
, font
, 0, 0))
23038 ascent
= min (max (0, (int)tem
), height
);
23040 ascent
= (height
* FONT_BASE (font
)) / FONT_HEIGHT (font
);
23042 if (width
> 0 && it
->line_wrap
!= TRUNCATE
23043 && it
->current_x
+ width
> it
->last_visible_x
)
23044 width
= it
->last_visible_x
- it
->current_x
- 1;
23046 if (width
> 0 && height
> 0 && it
->glyph_row
)
23048 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
23049 if (!STRINGP (object
))
23050 object
= it
->w
->buffer
;
23051 append_stretch_glyph (it
, object
, width
, height
, ascent
);
23054 it
->pixel_width
= width
;
23055 it
->ascent
= it
->phys_ascent
= ascent
;
23056 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
23057 it
->nglyphs
= width
> 0 && height
> 0 ? 1 : 0;
23059 take_vertical_position_into_account (it
);
23062 /* Calculate line-height and line-spacing properties.
23063 An integer value specifies explicit pixel value.
23064 A float value specifies relative value to current face height.
23065 A cons (float . face-name) specifies relative value to
23066 height of specified face font.
23068 Returns height in pixels, or nil. */
23072 calc_line_height_property (struct it
*it
, Lisp_Object val
, struct font
*font
,
23073 int boff
, int override
)
23075 Lisp_Object face_name
= Qnil
;
23076 int ascent
, descent
, height
;
23078 if (NILP (val
) || INTEGERP (val
) || (override
&& EQ (val
, Qt
)))
23083 face_name
= XCAR (val
);
23085 if (!NUMBERP (val
))
23086 val
= make_number (1);
23087 if (NILP (face_name
))
23089 height
= it
->ascent
+ it
->descent
;
23094 if (NILP (face_name
))
23096 font
= FRAME_FONT (it
->f
);
23097 boff
= FRAME_BASELINE_OFFSET (it
->f
);
23099 else if (EQ (face_name
, Qt
))
23108 face_id
= lookup_named_face (it
->f
, face_name
, 0);
23110 return make_number (-1);
23112 face
= FACE_FROM_ID (it
->f
, face_id
);
23115 return make_number (-1);
23116 boff
= font
->baseline_offset
;
23117 if (font
->vertical_centering
)
23118 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
23121 ascent
= FONT_BASE (font
) + boff
;
23122 descent
= FONT_DESCENT (font
) - boff
;
23126 it
->override_ascent
= ascent
;
23127 it
->override_descent
= descent
;
23128 it
->override_boff
= boff
;
23131 height
= ascent
+ descent
;
23135 height
= (int)(XFLOAT_DATA (val
) * height
);
23136 else if (INTEGERP (val
))
23137 height
*= XINT (val
);
23139 return make_number (height
);
23143 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
23144 is a face ID to be used for the glyph. FOR_NO_FONT is nonzero if
23145 and only if this is for a character for which no font was found.
23147 If the display method (it->glyphless_method) is
23148 GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
23149 length of the acronym or the hexadecimal string, UPPER_XOFF and
23150 UPPER_YOFF are pixel offsets for the upper part of the string,
23151 LOWER_XOFF and LOWER_YOFF are for the lower part.
23153 For the other display methods, LEN through LOWER_YOFF are zero. */
23156 append_glyphless_glyph (struct it
*it
, int face_id
, int for_no_font
, int len
,
23157 short upper_xoff
, short upper_yoff
,
23158 short lower_xoff
, short lower_yoff
)
23160 struct glyph
*glyph
;
23161 enum glyph_row_area area
= it
->area
;
23163 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
23164 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
23166 /* If the glyph row is reversed, we need to prepend the glyph
23167 rather than append it. */
23168 if (it
->glyph_row
->reversed_p
&& area
== TEXT_AREA
)
23172 /* Make room for the additional glyph. */
23173 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[area
]; g
--)
23175 glyph
= it
->glyph_row
->glyphs
[area
];
23177 glyph
->charpos
= CHARPOS (it
->position
);
23178 glyph
->object
= it
->object
;
23179 glyph
->pixel_width
= it
->pixel_width
;
23180 glyph
->ascent
= it
->ascent
;
23181 glyph
->descent
= it
->descent
;
23182 glyph
->voffset
= it
->voffset
;
23183 glyph
->type
= GLYPHLESS_GLYPH
;
23184 glyph
->u
.glyphless
.method
= it
->glyphless_method
;
23185 glyph
->u
.glyphless
.for_no_font
= for_no_font
;
23186 glyph
->u
.glyphless
.len
= len
;
23187 glyph
->u
.glyphless
.ch
= it
->c
;
23188 glyph
->slice
.glyphless
.upper_xoff
= upper_xoff
;
23189 glyph
->slice
.glyphless
.upper_yoff
= upper_yoff
;
23190 glyph
->slice
.glyphless
.lower_xoff
= lower_xoff
;
23191 glyph
->slice
.glyphless
.lower_yoff
= lower_yoff
;
23192 glyph
->avoid_cursor_p
= it
->avoid_cursor_p
;
23193 glyph
->multibyte_p
= it
->multibyte_p
;
23194 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
23195 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
23196 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
23197 || it
->phys_descent
> it
->descent
);
23198 glyph
->padding_p
= 0;
23199 glyph
->glyph_not_available_p
= 0;
23200 glyph
->face_id
= face_id
;
23201 glyph
->font_type
= FONT_TYPE_UNKNOWN
;
23204 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
23205 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
23207 glyph
->bidi_type
= it
->bidi_it
.type
;
23209 ++it
->glyph_row
->used
[area
];
23212 IT_EXPAND_MATRIX_WIDTH (it
, area
);
23216 /* Produce a glyph for a glyphless character for iterator IT.
23217 IT->glyphless_method specifies which method to use for displaying
23218 the character. See the description of enum
23219 glyphless_display_method in dispextern.h for the detail.
23221 FOR_NO_FONT is nonzero if and only if this is for a character for
23222 which no font was found. ACRONYM, if non-nil, is an acronym string
23223 for the character. */
23226 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
23231 int base_width
, base_height
, width
, height
;
23232 short upper_xoff
, upper_yoff
, lower_xoff
, lower_yoff
;
23235 /* Get the metrics of the base font. We always refer to the current
23237 face
= FACE_FROM_ID (it
->f
, it
->face_id
)->ascii_face
;
23238 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
23239 it
->ascent
= FONT_BASE (font
) + font
->baseline_offset
;
23240 it
->descent
= FONT_DESCENT (font
) - font
->baseline_offset
;
23241 base_height
= it
->ascent
+ it
->descent
;
23242 base_width
= font
->average_width
;
23244 /* Get a face ID for the glyph by utilizing a cache (the same way as
23245 doen for `escape-glyph' in get_next_display_element). */
23246 if (it
->f
== last_glyphless_glyph_frame
23247 && it
->face_id
== last_glyphless_glyph_face_id
)
23249 face_id
= last_glyphless_glyph_merged_face_id
;
23253 /* Merge the `glyphless-char' face into the current face. */
23254 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
23255 last_glyphless_glyph_frame
= it
->f
;
23256 last_glyphless_glyph_face_id
= it
->face_id
;
23257 last_glyphless_glyph_merged_face_id
= face_id
;
23260 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
23262 it
->pixel_width
= THIN_SPACE_WIDTH
;
23264 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
23266 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
23268 width
= CHAR_WIDTH (it
->c
);
23271 else if (width
> 4)
23273 it
->pixel_width
= base_width
* width
;
23275 upper_xoff
= upper_yoff
= lower_xoff
= lower_yoff
= 0;
23281 unsigned int code
[6];
23283 int ascent
, descent
;
23284 struct font_metrics metrics_upper
, metrics_lower
;
23286 face
= FACE_FROM_ID (it
->f
, face_id
);
23287 font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
23288 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
23290 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
23292 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
23293 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
23294 if (CONSP (acronym
))
23295 acronym
= XCAR (acronym
);
23296 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
23300 xassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
23301 sprintf (buf
, "%0*X", it
->c
< 0x10000 ? 4 : 6, it
->c
);
23304 for (len
= 0; str
[len
] && ASCII_BYTE_P (str
[len
]); len
++)
23305 code
[len
] = font
->driver
->encode_char (font
, str
[len
]);
23306 upper_len
= (len
+ 1) / 2;
23307 font
->driver
->text_extents (font
, code
, upper_len
,
23309 font
->driver
->text_extents (font
, code
+ upper_len
, len
- upper_len
,
23314 /* +4 is for vertical bars of a box plus 1-pixel spaces at both side. */
23315 width
= max (metrics_upper
.width
, metrics_lower
.width
) + 4;
23316 upper_xoff
= upper_yoff
= 2; /* the typical case */
23317 if (base_width
>= width
)
23319 /* Align the upper to the left, the lower to the right. */
23320 it
->pixel_width
= base_width
;
23321 lower_xoff
= base_width
- 2 - metrics_lower
.width
;
23325 /* Center the shorter one. */
23326 it
->pixel_width
= width
;
23327 if (metrics_upper
.width
>= metrics_lower
.width
)
23328 lower_xoff
= (width
- metrics_lower
.width
) / 2;
23331 /* FIXME: This code doesn't look right. It formerly was
23332 missing the "lower_xoff = 0;", which couldn't have
23333 been right since it left lower_xoff uninitialized. */
23335 upper_xoff
= (width
- metrics_upper
.width
) / 2;
23339 /* +5 is for horizontal bars of a box plus 1-pixel spaces at
23340 top, bottom, and between upper and lower strings. */
23341 height
= (metrics_upper
.ascent
+ metrics_upper
.descent
23342 + metrics_lower
.ascent
+ metrics_lower
.descent
) + 5;
23343 /* Center vertically.
23344 H:base_height, D:base_descent
23345 h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
23347 ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
23348 descent = D - H/2 + h/2;
23349 lower_yoff = descent - 2 - ld;
23350 upper_yoff = lower_yoff - la - 1 - ud; */
23351 ascent
= - (it
->descent
- (base_height
+ height
+ 1) / 2);
23352 descent
= it
->descent
- (base_height
- height
) / 2;
23353 lower_yoff
= descent
- 2 - metrics_lower
.descent
;
23354 upper_yoff
= (lower_yoff
- metrics_lower
.ascent
- 1
23355 - metrics_upper
.descent
);
23356 /* Don't make the height shorter than the base height. */
23357 if (height
> base_height
)
23359 it
->ascent
= ascent
;
23360 it
->descent
= descent
;
23364 it
->phys_ascent
= it
->ascent
;
23365 it
->phys_descent
= it
->descent
;
23367 append_glyphless_glyph (it
, face_id
, for_no_font
, len
,
23368 upper_xoff
, upper_yoff
,
23369 lower_xoff
, lower_yoff
);
23371 take_vertical_position_into_account (it
);
23376 Produce glyphs/get display metrics for the display element IT is
23377 loaded with. See the description of struct it in dispextern.h
23378 for an overview of struct it. */
23381 x_produce_glyphs (struct it
*it
)
23383 int extra_line_spacing
= it
->extra_line_spacing
;
23385 it
->glyph_not_available_p
= 0;
23387 if (it
->what
== IT_CHARACTER
)
23390 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23391 struct font
*font
= face
->font
;
23392 struct font_metrics
*pcm
= NULL
;
23393 int boff
; /* baseline offset */
23397 /* When no suitable font is found, display this character by
23398 the method specified in the first extra slot of
23399 Vglyphless_char_display. */
23400 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
23402 xassert (it
->what
== IT_GLYPHLESS
);
23403 produce_glyphless_glyph (it
, 1, STRINGP (acronym
) ? acronym
: Qnil
);
23407 boff
= font
->baseline_offset
;
23408 if (font
->vertical_centering
)
23409 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
23411 if (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t')
23417 if (it
->override_ascent
>= 0)
23419 it
->ascent
= it
->override_ascent
;
23420 it
->descent
= it
->override_descent
;
23421 boff
= it
->override_boff
;
23425 it
->ascent
= FONT_BASE (font
) + boff
;
23426 it
->descent
= FONT_DESCENT (font
) - boff
;
23429 if (get_char_glyph_code (it
->char_to_display
, font
, &char2b
))
23431 pcm
= get_per_char_metric (font
, &char2b
);
23432 if (pcm
->width
== 0
23433 && pcm
->rbearing
== 0 && pcm
->lbearing
== 0)
23439 it
->phys_ascent
= pcm
->ascent
+ boff
;
23440 it
->phys_descent
= pcm
->descent
- boff
;
23441 it
->pixel_width
= pcm
->width
;
23445 it
->glyph_not_available_p
= 1;
23446 it
->phys_ascent
= it
->ascent
;
23447 it
->phys_descent
= it
->descent
;
23448 it
->pixel_width
= font
->space_width
;
23451 if (it
->constrain_row_ascent_descent_p
)
23453 if (it
->descent
> it
->max_descent
)
23455 it
->ascent
+= it
->descent
- it
->max_descent
;
23456 it
->descent
= it
->max_descent
;
23458 if (it
->ascent
> it
->max_ascent
)
23460 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
23461 it
->ascent
= it
->max_ascent
;
23463 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
23464 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
23465 extra_line_spacing
= 0;
23468 /* If this is a space inside a region of text with
23469 `space-width' property, change its width. */
23470 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
23472 it
->pixel_width
*= XFLOATINT (it
->space_width
);
23474 /* If face has a box, add the box thickness to the character
23475 height. If character has a box line to the left and/or
23476 right, add the box line width to the character's width. */
23477 if (face
->box
!= FACE_NO_BOX
)
23479 int thick
= face
->box_line_width
;
23483 it
->ascent
+= thick
;
23484 it
->descent
+= thick
;
23489 if (it
->start_of_box_run_p
)
23490 it
->pixel_width
+= thick
;
23491 if (it
->end_of_box_run_p
)
23492 it
->pixel_width
+= thick
;
23495 /* If face has an overline, add the height of the overline
23496 (1 pixel) and a 1 pixel margin to the character height. */
23497 if (face
->overline_p
)
23498 it
->ascent
+= overline_margin
;
23500 if (it
->constrain_row_ascent_descent_p
)
23502 if (it
->ascent
> it
->max_ascent
)
23503 it
->ascent
= it
->max_ascent
;
23504 if (it
->descent
> it
->max_descent
)
23505 it
->descent
= it
->max_descent
;
23508 take_vertical_position_into_account (it
);
23510 /* If we have to actually produce glyphs, do it. */
23515 /* Translate a space with a `space-width' property
23516 into a stretch glyph. */
23517 int ascent
= (((it
->ascent
+ it
->descent
) * FONT_BASE (font
))
23518 / FONT_HEIGHT (font
));
23519 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
23520 it
->ascent
+ it
->descent
, ascent
);
23525 /* If characters with lbearing or rbearing are displayed
23526 in this line, record that fact in a flag of the
23527 glyph row. This is used to optimize X output code. */
23528 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
23529 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
23531 if (! stretched_p
&& it
->pixel_width
== 0)
23532 /* We assure that all visible glyphs have at least 1-pixel
23534 it
->pixel_width
= 1;
23536 else if (it
->char_to_display
== '\n')
23538 /* A newline has no width, but we need the height of the
23539 line. But if previous part of the line sets a height,
23540 don't increase that height */
23542 Lisp_Object height
;
23543 Lisp_Object total_height
= Qnil
;
23545 it
->override_ascent
= -1;
23546 it
->pixel_width
= 0;
23549 height
= get_it_property (it
, Qline_height
);
23550 /* Split (line-height total-height) list */
23552 && CONSP (XCDR (height
))
23553 && NILP (XCDR (XCDR (height
))))
23555 total_height
= XCAR (XCDR (height
));
23556 height
= XCAR (height
);
23558 height
= calc_line_height_property (it
, height
, font
, boff
, 1);
23560 if (it
->override_ascent
>= 0)
23562 it
->ascent
= it
->override_ascent
;
23563 it
->descent
= it
->override_descent
;
23564 boff
= it
->override_boff
;
23568 it
->ascent
= FONT_BASE (font
) + boff
;
23569 it
->descent
= FONT_DESCENT (font
) - boff
;
23572 if (EQ (height
, Qt
))
23574 if (it
->descent
> it
->max_descent
)
23576 it
->ascent
+= it
->descent
- it
->max_descent
;
23577 it
->descent
= it
->max_descent
;
23579 if (it
->ascent
> it
->max_ascent
)
23581 it
->descent
= min (it
->max_descent
, it
->descent
+ it
->ascent
- it
->max_ascent
);
23582 it
->ascent
= it
->max_ascent
;
23584 it
->phys_ascent
= min (it
->phys_ascent
, it
->ascent
);
23585 it
->phys_descent
= min (it
->phys_descent
, it
->descent
);
23586 it
->constrain_row_ascent_descent_p
= 1;
23587 extra_line_spacing
= 0;
23591 Lisp_Object spacing
;
23593 it
->phys_ascent
= it
->ascent
;
23594 it
->phys_descent
= it
->descent
;
23596 if ((it
->max_ascent
> 0 || it
->max_descent
> 0)
23597 && face
->box
!= FACE_NO_BOX
23598 && face
->box_line_width
> 0)
23600 it
->ascent
+= face
->box_line_width
;
23601 it
->descent
+= face
->box_line_width
;
23604 && XINT (height
) > it
->ascent
+ it
->descent
)
23605 it
->ascent
= XINT (height
) - it
->descent
;
23607 if (!NILP (total_height
))
23608 spacing
= calc_line_height_property (it
, total_height
, font
, boff
, 0);
23611 spacing
= get_it_property (it
, Qline_spacing
);
23612 spacing
= calc_line_height_property (it
, spacing
, font
, boff
, 0);
23614 if (INTEGERP (spacing
))
23616 extra_line_spacing
= XINT (spacing
);
23617 if (!NILP (total_height
))
23618 extra_line_spacing
-= (it
->phys_ascent
+ it
->phys_descent
);
23622 else /* i.e. (it->char_to_display == '\t') */
23624 if (font
->space_width
> 0)
23626 int tab_width
= it
->tab_width
* font
->space_width
;
23627 int x
= it
->current_x
+ it
->continuation_lines_width
;
23628 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
23630 /* If the distance from the current position to the next tab
23631 stop is less than a space character width, use the
23632 tab stop after that. */
23633 if (next_tab_x
- x
< font
->space_width
)
23634 next_tab_x
+= tab_width
;
23636 it
->pixel_width
= next_tab_x
- x
;
23638 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
23639 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
23643 append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
23644 it
->ascent
+ it
->descent
, it
->ascent
);
23649 it
->pixel_width
= 0;
23654 else if (it
->what
== IT_COMPOSITION
&& it
->cmp_it
.ch
< 0)
23656 /* A static composition.
23658 Note: A composition is represented as one glyph in the
23659 glyph matrix. There are no padding glyphs.
23661 Important note: pixel_width, ascent, and descent are the
23662 values of what is drawn by draw_glyphs (i.e. the values of
23663 the overall glyphs composed). */
23664 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23665 int boff
; /* baseline offset */
23666 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
23667 int glyph_len
= cmp
->glyph_len
;
23668 struct font
*font
= face
->font
;
23672 /* If we have not yet calculated pixel size data of glyphs of
23673 the composition for the current face font, calculate them
23674 now. Theoretically, we have to check all fonts for the
23675 glyphs, but that requires much time and memory space. So,
23676 here we check only the font of the first glyph. This may
23677 lead to incorrect display, but it's very rare, and C-l
23678 (recenter-top-bottom) can correct the display anyway. */
23679 if (! cmp
->font
|| cmp
->font
!= font
)
23681 /* Ascent and descent of the font of the first character
23682 of this composition (adjusted by baseline offset).
23683 Ascent and descent of overall glyphs should not be less
23684 than these, respectively. */
23685 int font_ascent
, font_descent
, font_height
;
23686 /* Bounding box of the overall glyphs. */
23687 int leftmost
, rightmost
, lowest
, highest
;
23688 int lbearing
, rbearing
;
23689 int i
, width
, ascent
, descent
;
23690 int left_padded
= 0, right_padded
= 0;
23691 int c
IF_LINT (= 0); /* cmp->glyph_len can't be zero; see Bug#8512 */
23693 struct font_metrics
*pcm
;
23694 int font_not_found_p
;
23697 for (glyph_len
= cmp
->glyph_len
; glyph_len
> 0; glyph_len
--)
23698 if ((c
= COMPOSITION_GLYPH (cmp
, glyph_len
- 1)) != '\t')
23700 if (glyph_len
< cmp
->glyph_len
)
23702 for (i
= 0; i
< glyph_len
; i
++)
23704 if ((c
= COMPOSITION_GLYPH (cmp
, i
)) != '\t')
23706 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
23711 pos
= (STRINGP (it
->string
) ? IT_STRING_CHARPOS (*it
)
23712 : IT_CHARPOS (*it
));
23713 /* If no suitable font is found, use the default font. */
23714 font_not_found_p
= font
== NULL
;
23715 if (font_not_found_p
)
23717 face
= face
->ascii_face
;
23720 boff
= font
->baseline_offset
;
23721 if (font
->vertical_centering
)
23722 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
23723 font_ascent
= FONT_BASE (font
) + boff
;
23724 font_descent
= FONT_DESCENT (font
) - boff
;
23725 font_height
= FONT_HEIGHT (font
);
23727 cmp
->font
= (void *) font
;
23730 if (! font_not_found_p
)
23732 get_char_face_and_encoding (it
->f
, c
, it
->face_id
,
23734 pcm
= get_per_char_metric (font
, &char2b
);
23737 /* Initialize the bounding box. */
23740 width
= pcm
->width
;
23741 ascent
= pcm
->ascent
;
23742 descent
= pcm
->descent
;
23743 lbearing
= pcm
->lbearing
;
23744 rbearing
= pcm
->rbearing
;
23748 width
= font
->space_width
;
23749 ascent
= FONT_BASE (font
);
23750 descent
= FONT_DESCENT (font
);
23757 lowest
= - descent
+ boff
;
23758 highest
= ascent
+ boff
;
23760 if (! font_not_found_p
23761 && font
->default_ascent
23762 && CHAR_TABLE_P (Vuse_default_ascent
)
23763 && !NILP (Faref (Vuse_default_ascent
,
23764 make_number (it
->char_to_display
))))
23765 highest
= font
->default_ascent
+ boff
;
23767 /* Draw the first glyph at the normal position. It may be
23768 shifted to right later if some other glyphs are drawn
23770 cmp
->offsets
[i
* 2] = 0;
23771 cmp
->offsets
[i
* 2 + 1] = boff
;
23772 cmp
->lbearing
= lbearing
;
23773 cmp
->rbearing
= rbearing
;
23775 /* Set cmp->offsets for the remaining glyphs. */
23776 for (i
++; i
< glyph_len
; i
++)
23778 int left
, right
, btm
, top
;
23779 int ch
= COMPOSITION_GLYPH (cmp
, i
);
23781 struct face
*this_face
;
23785 face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
, pos
, it
->string
);
23786 this_face
= FACE_FROM_ID (it
->f
, face_id
);
23787 font
= this_face
->font
;
23793 get_char_face_and_encoding (it
->f
, ch
, face_id
,
23795 pcm
= get_per_char_metric (font
, &char2b
);
23798 cmp
->offsets
[i
* 2] = cmp
->offsets
[i
* 2 + 1] = 0;
23801 width
= pcm
->width
;
23802 ascent
= pcm
->ascent
;
23803 descent
= pcm
->descent
;
23804 lbearing
= pcm
->lbearing
;
23805 rbearing
= pcm
->rbearing
;
23806 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
23808 /* Relative composition with or without
23809 alternate chars. */
23810 left
= (leftmost
+ rightmost
- width
) / 2;
23811 btm
= - descent
+ boff
;
23812 if (font
->relative_compose
23813 && (! CHAR_TABLE_P (Vignore_relative_composition
)
23814 || NILP (Faref (Vignore_relative_composition
,
23815 make_number (ch
)))))
23818 if (- descent
>= font
->relative_compose
)
23819 /* One extra pixel between two glyphs. */
23821 else if (ascent
<= 0)
23822 /* One extra pixel between two glyphs. */
23823 btm
= lowest
- 1 - ascent
- descent
;
23828 /* A composition rule is specified by an integer
23829 value that encodes global and new reference
23830 points (GREF and NREF). GREF and NREF are
23831 specified by numbers as below:
23833 0---1---2 -- ascent
23837 9--10--11 -- center
23839 ---3---4---5--- baseline
23841 6---7---8 -- descent
23843 int rule
= COMPOSITION_RULE (cmp
, i
);
23844 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
, xoff
, yoff
;
23846 COMPOSITION_DECODE_RULE (rule
, gref
, nref
, xoff
, yoff
);
23847 grefx
= gref
% 3, nrefx
= nref
% 3;
23848 grefy
= gref
/ 3, nrefy
= nref
/ 3;
23850 xoff
= font_height
* (xoff
- 128) / 256;
23852 yoff
= font_height
* (yoff
- 128) / 256;
23855 + grefx
* (rightmost
- leftmost
) / 2
23856 - nrefx
* width
/ 2
23859 btm
= ((grefy
== 0 ? highest
23861 : grefy
== 2 ? lowest
23862 : (highest
+ lowest
) / 2)
23863 - (nrefy
== 0 ? ascent
+ descent
23864 : nrefy
== 1 ? descent
- boff
23866 : (ascent
+ descent
) / 2)
23870 cmp
->offsets
[i
* 2] = left
;
23871 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
23873 /* Update the bounding box of the overall glyphs. */
23876 right
= left
+ width
;
23877 if (left
< leftmost
)
23879 if (right
> rightmost
)
23882 top
= btm
+ descent
+ ascent
;
23888 if (cmp
->lbearing
> left
+ lbearing
)
23889 cmp
->lbearing
= left
+ lbearing
;
23890 if (cmp
->rbearing
< left
+ rbearing
)
23891 cmp
->rbearing
= left
+ rbearing
;
23895 /* If there are glyphs whose x-offsets are negative,
23896 shift all glyphs to the right and make all x-offsets
23900 for (i
= 0; i
< cmp
->glyph_len
; i
++)
23901 cmp
->offsets
[i
* 2] -= leftmost
;
23902 rightmost
-= leftmost
;
23903 cmp
->lbearing
-= leftmost
;
23904 cmp
->rbearing
-= leftmost
;
23907 if (left_padded
&& cmp
->lbearing
< 0)
23909 for (i
= 0; i
< cmp
->glyph_len
; i
++)
23910 cmp
->offsets
[i
* 2] -= cmp
->lbearing
;
23911 rightmost
-= cmp
->lbearing
;
23912 cmp
->rbearing
-= cmp
->lbearing
;
23915 if (right_padded
&& rightmost
< cmp
->rbearing
)
23917 rightmost
= cmp
->rbearing
;
23920 cmp
->pixel_width
= rightmost
;
23921 cmp
->ascent
= highest
;
23922 cmp
->descent
= - lowest
;
23923 if (cmp
->ascent
< font_ascent
)
23924 cmp
->ascent
= font_ascent
;
23925 if (cmp
->descent
< font_descent
)
23926 cmp
->descent
= font_descent
;
23930 && (cmp
->lbearing
< 0
23931 || cmp
->rbearing
> cmp
->pixel_width
))
23932 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
23934 it
->pixel_width
= cmp
->pixel_width
;
23935 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
23936 it
->descent
= it
->phys_descent
= cmp
->descent
;
23937 if (face
->box
!= FACE_NO_BOX
)
23939 int thick
= face
->box_line_width
;
23943 it
->ascent
+= thick
;
23944 it
->descent
+= thick
;
23949 if (it
->start_of_box_run_p
)
23950 it
->pixel_width
+= thick
;
23951 if (it
->end_of_box_run_p
)
23952 it
->pixel_width
+= thick
;
23955 /* If face has an overline, add the height of the overline
23956 (1 pixel) and a 1 pixel margin to the character height. */
23957 if (face
->overline_p
)
23958 it
->ascent
+= overline_margin
;
23960 take_vertical_position_into_account (it
);
23961 if (it
->ascent
< 0)
23963 if (it
->descent
< 0)
23967 append_composite_glyph (it
);
23969 else if (it
->what
== IT_COMPOSITION
)
23971 /* A dynamic (automatic) composition. */
23972 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
23973 Lisp_Object gstring
;
23974 struct font_metrics metrics
;
23976 gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
23978 = composition_gstring_width (gstring
, it
->cmp_it
.from
, it
->cmp_it
.to
,
23981 && (metrics
.lbearing
< 0 || metrics
.rbearing
> metrics
.width
))
23982 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
23983 it
->ascent
= it
->phys_ascent
= metrics
.ascent
;
23984 it
->descent
= it
->phys_descent
= metrics
.descent
;
23985 if (face
->box
!= FACE_NO_BOX
)
23987 int thick
= face
->box_line_width
;
23991 it
->ascent
+= thick
;
23992 it
->descent
+= thick
;
23997 if (it
->start_of_box_run_p
)
23998 it
->pixel_width
+= thick
;
23999 if (it
->end_of_box_run_p
)
24000 it
->pixel_width
+= thick
;
24002 /* If face has an overline, add the height of the overline
24003 (1 pixel) and a 1 pixel margin to the character height. */
24004 if (face
->overline_p
)
24005 it
->ascent
+= overline_margin
;
24006 take_vertical_position_into_account (it
);
24007 if (it
->ascent
< 0)
24009 if (it
->descent
< 0)
24013 append_composite_glyph (it
);
24015 else if (it
->what
== IT_GLYPHLESS
)
24016 produce_glyphless_glyph (it
, 0, Qnil
);
24017 else if (it
->what
== IT_IMAGE
)
24018 produce_image_glyph (it
);
24019 else if (it
->what
== IT_STRETCH
)
24020 produce_stretch_glyph (it
);
24023 /* Accumulate dimensions. Note: can't assume that it->descent > 0
24024 because this isn't true for images with `:ascent 100'. */
24025 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
24026 if (it
->area
== TEXT_AREA
)
24027 it
->current_x
+= it
->pixel_width
;
24029 if (extra_line_spacing
> 0)
24031 it
->descent
+= extra_line_spacing
;
24032 if (extra_line_spacing
> it
->max_extra_line_spacing
)
24033 it
->max_extra_line_spacing
= extra_line_spacing
;
24036 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
24037 it
->max_descent
= max (it
->max_descent
, it
->descent
);
24038 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
24039 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
24043 Output LEN glyphs starting at START at the nominal cursor position.
24044 Advance the nominal cursor over the text. The global variable
24045 updated_window contains the window being updated, updated_row is
24046 the glyph row being updated, and updated_area is the area of that
24047 row being updated. */
24050 x_write_glyphs (struct glyph
*start
, int len
)
24054 xassert (updated_window
&& updated_row
);
24057 /* Write glyphs. */
24059 hpos
= start
- updated_row
->glyphs
[updated_area
];
24060 x
= draw_glyphs (updated_window
, output_cursor
.x
,
24061 updated_row
, updated_area
,
24063 DRAW_NORMAL_TEXT
, 0);
24065 /* Invalidate old phys cursor if the glyph at its hpos is redrawn. */
24066 if (updated_area
== TEXT_AREA
24067 && updated_window
->phys_cursor_on_p
24068 && updated_window
->phys_cursor
.vpos
== output_cursor
.vpos
24069 && updated_window
->phys_cursor
.hpos
>= hpos
24070 && updated_window
->phys_cursor
.hpos
< hpos
+ len
)
24071 updated_window
->phys_cursor_on_p
= 0;
24075 /* Advance the output cursor. */
24076 output_cursor
.hpos
+= len
;
24077 output_cursor
.x
= x
;
24082 Insert LEN glyphs from START at the nominal cursor position. */
24085 x_insert_glyphs (struct glyph
*start
, int len
)
24089 int line_height
, shift_by_width
, shifted_region_width
;
24090 struct glyph_row
*row
;
24091 struct glyph
*glyph
;
24092 int frame_x
, frame_y
;
24095 xassert (updated_window
&& updated_row
);
24097 w
= updated_window
;
24098 f
= XFRAME (WINDOW_FRAME (w
));
24100 /* Get the height of the line we are in. */
24102 line_height
= row
->height
;
24104 /* Get the width of the glyphs to insert. */
24105 shift_by_width
= 0;
24106 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
24107 shift_by_width
+= glyph
->pixel_width
;
24109 /* Get the width of the region to shift right. */
24110 shifted_region_width
= (window_box_width (w
, updated_area
)
24115 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
24116 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
24118 FRAME_RIF (f
)->shift_glyphs_for_insert (f
, frame_x
, frame_y
, shifted_region_width
,
24119 line_height
, shift_by_width
);
24121 /* Write the glyphs. */
24122 hpos
= start
- row
->glyphs
[updated_area
];
24123 draw_glyphs (w
, output_cursor
.x
, row
, updated_area
,
24125 DRAW_NORMAL_TEXT
, 0);
24127 /* Advance the output cursor. */
24128 output_cursor
.hpos
+= len
;
24129 output_cursor
.x
+= shift_by_width
;
24135 Erase the current text line from the nominal cursor position
24136 (inclusive) to pixel column TO_X (exclusive). The idea is that
24137 everything from TO_X onward is already erased.
24139 TO_X is a pixel position relative to updated_area of
24140 updated_window. TO_X == -1 means clear to the end of this area. */
24143 x_clear_end_of_line (int to_x
)
24146 struct window
*w
= updated_window
;
24147 int max_x
, min_y
, max_y
;
24148 int from_x
, from_y
, to_y
;
24150 xassert (updated_window
&& updated_row
);
24151 f
= XFRAME (w
->frame
);
24153 if (updated_row
->full_width_p
)
24154 max_x
= WINDOW_TOTAL_WIDTH (w
);
24156 max_x
= window_box_width (w
, updated_area
);
24157 max_y
= window_text_bottom_y (w
);
24159 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
24160 of window. For TO_X > 0, truncate to end of drawing area. */
24166 to_x
= min (to_x
, max_x
);
24168 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
24170 /* Notice if the cursor will be cleared by this operation. */
24171 if (!updated_row
->full_width_p
)
24172 notice_overwritten_cursor (w
, updated_area
,
24173 output_cursor
.x
, -1,
24175 MATRIX_ROW_BOTTOM_Y (updated_row
));
24177 from_x
= output_cursor
.x
;
24179 /* Translate to frame coordinates. */
24180 if (updated_row
->full_width_p
)
24182 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
24183 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
24187 int area_left
= window_box_left (w
, updated_area
);
24188 from_x
+= area_left
;
24192 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
24193 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
24194 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
24196 /* Prevent inadvertently clearing to end of the X window. */
24197 if (to_x
> from_x
&& to_y
> from_y
)
24200 FRAME_RIF (f
)->clear_frame_area (f
, from_x
, from_y
,
24201 to_x
- from_x
, to_y
- from_y
);
24206 #endif /* HAVE_WINDOW_SYSTEM */
24210 /***********************************************************************
24212 ***********************************************************************/
24214 /* Value is the internal representation of the specified cursor type
24215 ARG. If type is BAR_CURSOR, return in *WIDTH the specified width
24216 of the bar cursor. */
24218 static enum text_cursor_kinds
24219 get_specified_cursor_type (Lisp_Object arg
, int *width
)
24221 enum text_cursor_kinds type
;
24226 if (EQ (arg
, Qbox
))
24227 return FILLED_BOX_CURSOR
;
24229 if (EQ (arg
, Qhollow
))
24230 return HOLLOW_BOX_CURSOR
;
24232 if (EQ (arg
, Qbar
))
24239 && EQ (XCAR (arg
), Qbar
)
24240 && INTEGERP (XCDR (arg
))
24241 && XINT (XCDR (arg
)) >= 0)
24243 *width
= XINT (XCDR (arg
));
24247 if (EQ (arg
, Qhbar
))
24250 return HBAR_CURSOR
;
24254 && EQ (XCAR (arg
), Qhbar
)
24255 && INTEGERP (XCDR (arg
))
24256 && XINT (XCDR (arg
)) >= 0)
24258 *width
= XINT (XCDR (arg
));
24259 return HBAR_CURSOR
;
24262 /* Treat anything unknown as "hollow box cursor".
24263 It was bad to signal an error; people have trouble fixing
24264 .Xdefaults with Emacs, when it has something bad in it. */
24265 type
= HOLLOW_BOX_CURSOR
;
24270 /* Set the default cursor types for specified frame. */
24272 set_frame_cursor_types (struct frame
*f
, Lisp_Object arg
)
24277 FRAME_DESIRED_CURSOR (f
) = get_specified_cursor_type (arg
, &width
);
24278 FRAME_CURSOR_WIDTH (f
) = width
;
24280 /* By default, set up the blink-off state depending on the on-state. */
24282 tem
= Fassoc (arg
, Vblink_cursor_alist
);
24285 FRAME_BLINK_OFF_CURSOR (f
)
24286 = get_specified_cursor_type (XCDR (tem
), &width
);
24287 FRAME_BLINK_OFF_CURSOR_WIDTH (f
) = width
;
24290 FRAME_BLINK_OFF_CURSOR (f
) = DEFAULT_CURSOR
;
24294 #ifdef HAVE_WINDOW_SYSTEM
24296 /* Return the cursor we want to be displayed in window W. Return
24297 width of bar/hbar cursor through WIDTH arg. Return with
24298 ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
24299 (i.e. if the `system caret' should track this cursor).
24301 In a mini-buffer window, we want the cursor only to appear if we
24302 are reading input from this window. For the selected window, we
24303 want the cursor type given by the frame parameter or buffer local
24304 setting of cursor-type. If explicitly marked off, draw no cursor.
24305 In all other cases, we want a hollow box cursor. */
24307 static enum text_cursor_kinds
24308 get_window_cursor_type (struct window
*w
, struct glyph
*glyph
, int *width
,
24309 int *active_cursor
)
24311 struct frame
*f
= XFRAME (w
->frame
);
24312 struct buffer
*b
= XBUFFER (w
->buffer
);
24313 int cursor_type
= DEFAULT_CURSOR
;
24314 Lisp_Object alt_cursor
;
24315 int non_selected
= 0;
24317 *active_cursor
= 1;
24320 if (cursor_in_echo_area
24321 && FRAME_HAS_MINIBUF_P (f
)
24322 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
24324 if (w
== XWINDOW (echo_area_window
))
24326 if (EQ (BVAR (b
, cursor_type
), Qt
) || NILP (BVAR (b
, cursor_type
)))
24328 *width
= FRAME_CURSOR_WIDTH (f
);
24329 return FRAME_DESIRED_CURSOR (f
);
24332 return get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
24335 *active_cursor
= 0;
24339 /* Detect a nonselected window or nonselected frame. */
24340 else if (w
!= XWINDOW (f
->selected_window
)
24341 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
24343 *active_cursor
= 0;
24345 if (MINI_WINDOW_P (w
) && minibuf_level
== 0)
24351 /* Never display a cursor in a window in which cursor-type is nil. */
24352 if (NILP (BVAR (b
, cursor_type
)))
24355 /* Get the normal cursor type for this window. */
24356 if (EQ (BVAR (b
, cursor_type
), Qt
))
24358 cursor_type
= FRAME_DESIRED_CURSOR (f
);
24359 *width
= FRAME_CURSOR_WIDTH (f
);
24362 cursor_type
= get_specified_cursor_type (BVAR (b
, cursor_type
), width
);
24364 /* Use cursor-in-non-selected-windows instead
24365 for non-selected window or frame. */
24368 alt_cursor
= BVAR (b
, cursor_in_non_selected_windows
);
24369 if (!EQ (Qt
, alt_cursor
))
24370 return get_specified_cursor_type (alt_cursor
, width
);
24371 /* t means modify the normal cursor type. */
24372 if (cursor_type
== FILLED_BOX_CURSOR
)
24373 cursor_type
= HOLLOW_BOX_CURSOR
;
24374 else if (cursor_type
== BAR_CURSOR
&& *width
> 1)
24376 return cursor_type
;
24379 /* Use normal cursor if not blinked off. */
24380 if (!w
->cursor_off_p
)
24382 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
24384 if (cursor_type
== FILLED_BOX_CURSOR
)
24386 /* Using a block cursor on large images can be very annoying.
24387 So use a hollow cursor for "large" images.
24388 If image is not transparent (no mask), also use hollow cursor. */
24389 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
24390 if (img
!= NULL
&& IMAGEP (img
->spec
))
24392 /* Arbitrarily, interpret "Large" as >32x32 and >NxN
24393 where N = size of default frame font size.
24394 This should cover most of the "tiny" icons people may use. */
24396 || img
->width
> max (32, WINDOW_FRAME_COLUMN_WIDTH (w
))
24397 || img
->height
> max (32, WINDOW_FRAME_LINE_HEIGHT (w
)))
24398 cursor_type
= HOLLOW_BOX_CURSOR
;
24401 else if (cursor_type
!= NO_CURSOR
)
24403 /* Display current only supports BOX and HOLLOW cursors for images.
24404 So for now, unconditionally use a HOLLOW cursor when cursor is
24405 not a solid box cursor. */
24406 cursor_type
= HOLLOW_BOX_CURSOR
;
24409 return cursor_type
;
24412 /* Cursor is blinked off, so determine how to "toggle" it. */
24414 /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist. */
24415 if ((alt_cursor
= Fassoc (BVAR (b
, cursor_type
), Vblink_cursor_alist
), !NILP (alt_cursor
)))
24416 return get_specified_cursor_type (XCDR (alt_cursor
), width
);
24418 /* Then see if frame has specified a specific blink off cursor type. */
24419 if (FRAME_BLINK_OFF_CURSOR (f
) != DEFAULT_CURSOR
)
24421 *width
= FRAME_BLINK_OFF_CURSOR_WIDTH (f
);
24422 return FRAME_BLINK_OFF_CURSOR (f
);
24426 /* Some people liked having a permanently visible blinking cursor,
24427 while others had very strong opinions against it. So it was
24428 decided to remove it. KFS 2003-09-03 */
24430 /* Finally perform built-in cursor blinking:
24431 filled box <-> hollow box
24432 wide [h]bar <-> narrow [h]bar
24433 narrow [h]bar <-> no cursor
24434 other type <-> no cursor */
24436 if (cursor_type
== FILLED_BOX_CURSOR
)
24437 return HOLLOW_BOX_CURSOR
;
24439 if ((cursor_type
== BAR_CURSOR
|| cursor_type
== HBAR_CURSOR
) && *width
> 1)
24442 return cursor_type
;
24450 /* Notice when the text cursor of window W has been completely
24451 overwritten by a drawing operation that outputs glyphs in AREA
24452 starting at X0 and ending at X1 in the line starting at Y0 and
24453 ending at Y1. X coordinates are area-relative. X1 < 0 means all
24454 the rest of the line after X0 has been written. Y coordinates
24455 are window-relative. */
24458 notice_overwritten_cursor (struct window
*w
, enum glyph_row_area area
,
24459 int x0
, int x1
, int y0
, int y1
)
24461 int cx0
, cx1
, cy0
, cy1
;
24462 struct glyph_row
*row
;
24464 if (!w
->phys_cursor_on_p
)
24466 if (area
!= TEXT_AREA
)
24469 if (w
->phys_cursor
.vpos
< 0
24470 || w
->phys_cursor
.vpos
>= w
->current_matrix
->nrows
24471 || (row
= w
->current_matrix
->rows
+ w
->phys_cursor
.vpos
,
24472 !(row
->enabled_p
&& row
->displays_text_p
)))
24475 if (row
->cursor_in_fringe_p
)
24477 row
->cursor_in_fringe_p
= 0;
24478 draw_fringe_bitmap (w
, row
, row
->reversed_p
);
24479 w
->phys_cursor_on_p
= 0;
24483 cx0
= w
->phys_cursor
.x
;
24484 cx1
= cx0
+ w
->phys_cursor_width
;
24485 if (x0
> cx0
|| (x1
>= 0 && x1
< cx1
))
24488 /* The cursor image will be completely removed from the
24489 screen if the output area intersects the cursor area in
24490 y-direction. When we draw in [y0 y1[, and some part of
24491 the cursor is at y < y0, that part must have been drawn
24492 before. When scrolling, the cursor is erased before
24493 actually scrolling, so we don't come here. When not
24494 scrolling, the rows above the old cursor row must have
24495 changed, and in this case these rows must have written
24496 over the cursor image.
24498 Likewise if part of the cursor is below y1, with the
24499 exception of the cursor being in the first blank row at
24500 the buffer and window end because update_text_area
24501 doesn't draw that row. (Except when it does, but
24502 that's handled in update_text_area.) */
24504 cy0
= w
->phys_cursor
.y
;
24505 cy1
= cy0
+ w
->phys_cursor_height
;
24506 if ((y0
< cy0
|| y0
>= cy1
) && (y1
<= cy0
|| y1
>= cy1
))
24509 w
->phys_cursor_on_p
= 0;
24512 #endif /* HAVE_WINDOW_SYSTEM */
24515 /************************************************************************
24517 ************************************************************************/
24519 #ifdef HAVE_WINDOW_SYSTEM
24522 Fix the display of area AREA of overlapping row ROW in window W
24523 with respect to the overlapping part OVERLAPS. */
24526 x_fix_overlapping_area (struct window
*w
, struct glyph_row
*row
,
24527 enum glyph_row_area area
, int overlaps
)
24534 for (i
= 0; i
< row
->used
[area
];)
24536 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
24538 int start
= i
, start_x
= x
;
24542 x
+= row
->glyphs
[area
][i
].pixel_width
;
24545 while (i
< row
->used
[area
]
24546 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
24548 draw_glyphs (w
, start_x
, row
, area
,
24550 DRAW_NORMAL_TEXT
, overlaps
);
24554 x
+= row
->glyphs
[area
][i
].pixel_width
;
24564 Draw the cursor glyph of window W in glyph row ROW. See the
24565 comment of draw_glyphs for the meaning of HL. */
24568 draw_phys_cursor_glyph (struct window
*w
, struct glyph_row
*row
,
24569 enum draw_glyphs_face hl
)
24571 /* If cursor hpos is out of bounds, don't draw garbage. This can
24572 happen in mini-buffer windows when switching between echo area
24573 glyphs and mini-buffer. */
24574 if ((row
->reversed_p
24575 ? (w
->phys_cursor
.hpos
>= 0)
24576 : (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])))
24578 int on_p
= w
->phys_cursor_on_p
;
24580 x1
= draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
24581 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
24583 w
->phys_cursor_on_p
= on_p
;
24585 if (hl
== DRAW_CURSOR
)
24586 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
24587 /* When we erase the cursor, and ROW is overlapped by other
24588 rows, make sure that these overlapping parts of other rows
24590 else if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
24592 w
->phys_cursor_width
= x1
- w
->phys_cursor
.x
;
24594 if (row
> w
->current_matrix
->rows
24595 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
24596 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
,
24597 OVERLAPS_ERASED_CURSOR
);
24599 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
24600 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
24601 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
,
24602 OVERLAPS_ERASED_CURSOR
);
24609 Erase the image of a cursor of window W from the screen. */
24612 erase_phys_cursor (struct window
*w
)
24614 struct frame
*f
= XFRAME (w
->frame
);
24615 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
24616 int hpos
= w
->phys_cursor
.hpos
;
24617 int vpos
= w
->phys_cursor
.vpos
;
24618 int mouse_face_here_p
= 0;
24619 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
24620 struct glyph_row
*cursor_row
;
24621 struct glyph
*cursor_glyph
;
24622 enum draw_glyphs_face hl
;
24624 /* No cursor displayed or row invalidated => nothing to do on the
24626 if (w
->phys_cursor_type
== NO_CURSOR
)
24627 goto mark_cursor_off
;
24629 /* VPOS >= active_glyphs->nrows means that window has been resized.
24630 Don't bother to erase the cursor. */
24631 if (vpos
>= active_glyphs
->nrows
)
24632 goto mark_cursor_off
;
24634 /* If row containing cursor is marked invalid, there is nothing we
24636 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
24637 if (!cursor_row
->enabled_p
)
24638 goto mark_cursor_off
;
24640 /* If line spacing is > 0, old cursor may only be partially visible in
24641 window after split-window. So adjust visible height. */
24642 cursor_row
->visible_height
= min (cursor_row
->visible_height
,
24643 window_text_bottom_y (w
) - cursor_row
->y
);
24645 /* If row is completely invisible, don't attempt to delete a cursor which
24646 isn't there. This can happen if cursor is at top of a window, and
24647 we switch to a buffer with a header line in that window. */
24648 if (cursor_row
->visible_height
<= 0)
24649 goto mark_cursor_off
;
24651 /* If cursor is in the fringe, erase by drawing actual bitmap there. */
24652 if (cursor_row
->cursor_in_fringe_p
)
24654 cursor_row
->cursor_in_fringe_p
= 0;
24655 draw_fringe_bitmap (w
, cursor_row
, cursor_row
->reversed_p
);
24656 goto mark_cursor_off
;
24659 /* This can happen when the new row is shorter than the old one.
24660 In this case, either draw_glyphs or clear_end_of_line
24661 should have cleared the cursor. Note that we wouldn't be
24662 able to erase the cursor in this case because we don't have a
24663 cursor glyph at hand. */
24664 if ((cursor_row
->reversed_p
24665 ? (w
->phys_cursor
.hpos
< 0)
24666 : (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])))
24667 goto mark_cursor_off
;
24669 /* If the cursor is in the mouse face area, redisplay that when
24670 we clear the cursor. */
24671 if (! NILP (hlinfo
->mouse_face_window
)
24672 && coords_in_mouse_face_p (w
, hpos
, vpos
)
24673 /* Don't redraw the cursor's spot in mouse face if it is at the
24674 end of a line (on a newline). The cursor appears there, but
24675 mouse highlighting does not. */
24676 && cursor_row
->used
[TEXT_AREA
] > hpos
&& hpos
>= 0)
24677 mouse_face_here_p
= 1;
24679 /* Maybe clear the display under the cursor. */
24680 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
24683 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
24686 cursor_glyph
= get_phys_cursor_glyph (w
);
24687 if (cursor_glyph
== NULL
)
24688 goto mark_cursor_off
;
24690 width
= cursor_glyph
->pixel_width
;
24691 left_x
= window_box_left_offset (w
, TEXT_AREA
);
24692 x
= w
->phys_cursor
.x
;
24694 width
-= left_x
- x
;
24695 width
= min (width
, window_box_width (w
, TEXT_AREA
) - x
);
24696 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
, cursor_row
->y
));
24697 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, max (x
, left_x
));
24700 FRAME_RIF (f
)->clear_frame_area (f
, x
, y
, width
, cursor_row
->visible_height
);
24703 /* Erase the cursor by redrawing the character underneath it. */
24704 if (mouse_face_here_p
)
24705 hl
= DRAW_MOUSE_FACE
;
24707 hl
= DRAW_NORMAL_TEXT
;
24708 draw_phys_cursor_glyph (w
, cursor_row
, hl
);
24711 w
->phys_cursor_on_p
= 0;
24712 w
->phys_cursor_type
= NO_CURSOR
;
24717 Display or clear cursor of window W. If ON is zero, clear the
24718 cursor. If it is non-zero, display the cursor. If ON is nonzero,
24719 where to put the cursor is specified by HPOS, VPOS, X and Y. */
24722 display_and_set_cursor (struct window
*w
, int on
,
24723 int hpos
, int vpos
, int x
, int y
)
24725 struct frame
*f
= XFRAME (w
->frame
);
24726 int new_cursor_type
;
24727 int new_cursor_width
;
24729 struct glyph_row
*glyph_row
;
24730 struct glyph
*glyph
;
24732 /* This is pointless on invisible frames, and dangerous on garbaged
24733 windows and frames; in the latter case, the frame or window may
24734 be in the midst of changing its size, and x and y may be off the
24736 if (! FRAME_VISIBLE_P (f
)
24737 || FRAME_GARBAGED_P (f
)
24738 || vpos
>= w
->current_matrix
->nrows
24739 || hpos
>= w
->current_matrix
->matrix_w
)
24742 /* If cursor is off and we want it off, return quickly. */
24743 if (!on
&& !w
->phys_cursor_on_p
)
24746 glyph_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
24747 /* If cursor row is not enabled, we don't really know where to
24748 display the cursor. */
24749 if (!glyph_row
->enabled_p
)
24751 w
->phys_cursor_on_p
= 0;
24756 if (!glyph_row
->exact_window_width_line_p
24757 || (0 <= hpos
&& hpos
< glyph_row
->used
[TEXT_AREA
]))
24758 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
24760 xassert (interrupt_input_blocked
);
24762 /* Set new_cursor_type to the cursor we want to be displayed. */
24763 new_cursor_type
= get_window_cursor_type (w
, glyph
,
24764 &new_cursor_width
, &active_cursor
);
24766 /* If cursor is currently being shown and we don't want it to be or
24767 it is in the wrong place, or the cursor type is not what we want,
24769 if (w
->phys_cursor_on_p
24771 || w
->phys_cursor
.x
!= x
24772 || w
->phys_cursor
.y
!= y
24773 || new_cursor_type
!= w
->phys_cursor_type
24774 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
24775 && new_cursor_width
!= w
->phys_cursor_width
)))
24776 erase_phys_cursor (w
);
24778 /* Don't check phys_cursor_on_p here because that flag is only set
24779 to zero in some cases where we know that the cursor has been
24780 completely erased, to avoid the extra work of erasing the cursor
24781 twice. In other words, phys_cursor_on_p can be 1 and the cursor
24782 still not be visible, or it has only been partly erased. */
24785 w
->phys_cursor_ascent
= glyph_row
->ascent
;
24786 w
->phys_cursor_height
= glyph_row
->height
;
24788 /* Set phys_cursor_.* before x_draw_.* is called because some
24789 of them may need the information. */
24790 w
->phys_cursor
.x
= x
;
24791 w
->phys_cursor
.y
= glyph_row
->y
;
24792 w
->phys_cursor
.hpos
= hpos
;
24793 w
->phys_cursor
.vpos
= vpos
;
24796 FRAME_RIF (f
)->draw_window_cursor (w
, glyph_row
, x
, y
,
24797 new_cursor_type
, new_cursor_width
,
24798 on
, active_cursor
);
24802 /* Switch the display of W's cursor on or off, according to the value
24806 update_window_cursor (struct window
*w
, int on
)
24808 /* Don't update cursor in windows whose frame is in the process
24809 of being deleted. */
24810 if (w
->current_matrix
)
24813 display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
24814 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
24820 /* Call update_window_cursor with parameter ON_P on all leaf windows
24821 in the window tree rooted at W. */
24824 update_cursor_in_window_tree (struct window
*w
, int on_p
)
24828 if (!NILP (w
->hchild
))
24829 update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
24830 else if (!NILP (w
->vchild
))
24831 update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
24833 update_window_cursor (w
, on_p
);
24835 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
24841 Display the cursor on window W, or clear it, according to ON_P.
24842 Don't change the cursor's position. */
24845 x_update_cursor (struct frame
*f
, int on_p
)
24847 update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
24852 Clear the cursor of window W to background color, and mark the
24853 cursor as not shown. This is used when the text where the cursor
24854 is about to be rewritten. */
24857 x_clear_cursor (struct window
*w
)
24859 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
24860 update_window_cursor (w
, 0);
24863 #endif /* HAVE_WINDOW_SYSTEM */
24865 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
24868 draw_row_with_mouse_face (struct window
*w
, int start_x
, struct glyph_row
*row
,
24869 int start_hpos
, int end_hpos
,
24870 enum draw_glyphs_face draw
)
24872 #ifdef HAVE_WINDOW_SYSTEM
24873 if (FRAME_WINDOW_P (XFRAME (w
->frame
)))
24875 draw_glyphs (w
, start_x
, row
, TEXT_AREA
, start_hpos
, end_hpos
, draw
, 0);
24879 #if defined (HAVE_GPM) || defined (MSDOS)
24880 tty_draw_row_with_mouse_face (w
, row
, start_hpos
, end_hpos
, draw
);
24884 /* Display the active region described by mouse_face_* according to DRAW. */
24887 show_mouse_face (Mouse_HLInfo
*hlinfo
, enum draw_glyphs_face draw
)
24889 struct window
*w
= XWINDOW (hlinfo
->mouse_face_window
);
24890 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
24892 if (/* If window is in the process of being destroyed, don't bother
24894 w
->current_matrix
!= NULL
24895 /* Don't update mouse highlight if hidden */
24896 && (draw
!= DRAW_MOUSE_FACE
|| !hlinfo
->mouse_face_hidden
)
24897 /* Recognize when we are called to operate on rows that don't exist
24898 anymore. This can happen when a window is split. */
24899 && hlinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
24901 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
24902 struct glyph_row
*row
, *first
, *last
;
24904 first
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_beg_row
);
24905 last
= MATRIX_ROW (w
->current_matrix
, hlinfo
->mouse_face_end_row
);
24907 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
24909 int start_hpos
, end_hpos
, start_x
;
24911 /* For all but the first row, the highlight starts at column 0. */
24914 /* R2L rows have BEG and END in reversed order, but the
24915 screen drawing geometry is always left to right. So
24916 we need to mirror the beginning and end of the
24917 highlighted area in R2L rows. */
24918 if (!row
->reversed_p
)
24920 start_hpos
= hlinfo
->mouse_face_beg_col
;
24921 start_x
= hlinfo
->mouse_face_beg_x
;
24923 else if (row
== last
)
24925 start_hpos
= hlinfo
->mouse_face_end_col
;
24926 start_x
= hlinfo
->mouse_face_end_x
;
24934 else if (row
->reversed_p
&& row
== last
)
24936 start_hpos
= hlinfo
->mouse_face_end_col
;
24937 start_x
= hlinfo
->mouse_face_end_x
;
24947 if (!row
->reversed_p
)
24948 end_hpos
= hlinfo
->mouse_face_end_col
;
24949 else if (row
== first
)
24950 end_hpos
= hlinfo
->mouse_face_beg_col
;
24953 end_hpos
= row
->used
[TEXT_AREA
];
24954 if (draw
== DRAW_NORMAL_TEXT
)
24955 row
->fill_line_p
= 1; /* Clear to end of line */
24958 else if (row
->reversed_p
&& row
== first
)
24959 end_hpos
= hlinfo
->mouse_face_beg_col
;
24962 end_hpos
= row
->used
[TEXT_AREA
];
24963 if (draw
== DRAW_NORMAL_TEXT
)
24964 row
->fill_line_p
= 1; /* Clear to end of line */
24967 if (end_hpos
> start_hpos
)
24969 draw_row_with_mouse_face (w
, start_x
, row
,
24970 start_hpos
, end_hpos
, draw
);
24973 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
24977 #ifdef HAVE_WINDOW_SYSTEM
24978 /* When we've written over the cursor, arrange for it to
24979 be displayed again. */
24980 if (FRAME_WINDOW_P (f
)
24981 && phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
24984 display_and_set_cursor (w
, 1,
24985 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
24986 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
24989 #endif /* HAVE_WINDOW_SYSTEM */
24992 #ifdef HAVE_WINDOW_SYSTEM
24993 /* Change the mouse cursor. */
24994 if (FRAME_WINDOW_P (f
))
24996 if (draw
== DRAW_NORMAL_TEXT
24997 && !EQ (hlinfo
->mouse_face_window
, f
->tool_bar_window
))
24998 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->text_cursor
);
24999 else if (draw
== DRAW_MOUSE_FACE
)
25000 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->hand_cursor
);
25002 FRAME_RIF (f
)->define_frame_cursor (f
, FRAME_X_OUTPUT (f
)->nontext_cursor
);
25004 #endif /* HAVE_WINDOW_SYSTEM */
25008 Clear out the mouse-highlighted active region.
25009 Redraw it un-highlighted first. Value is non-zero if mouse
25010 face was actually drawn unhighlighted. */
25013 clear_mouse_face (Mouse_HLInfo
*hlinfo
)
25017 if (!hlinfo
->mouse_face_hidden
&& !NILP (hlinfo
->mouse_face_window
))
25019 show_mouse_face (hlinfo
, DRAW_NORMAL_TEXT
);
25023 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
25024 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
25025 hlinfo
->mouse_face_window
= Qnil
;
25026 hlinfo
->mouse_face_overlay
= Qnil
;
25030 /* Return non-zero if the coordinates HPOS and VPOS on windows W are
25031 within the mouse face on that window. */
25033 coords_in_mouse_face_p (struct window
*w
, int hpos
, int vpos
)
25035 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
25037 /* Quickly resolve the easy cases. */
25038 if (!(WINDOWP (hlinfo
->mouse_face_window
)
25039 && XWINDOW (hlinfo
->mouse_face_window
) == w
))
25041 if (vpos
< hlinfo
->mouse_face_beg_row
25042 || vpos
> hlinfo
->mouse_face_end_row
)
25044 if (vpos
> hlinfo
->mouse_face_beg_row
25045 && vpos
< hlinfo
->mouse_face_end_row
)
25048 if (!MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
)
25050 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
25052 if (hlinfo
->mouse_face_beg_col
<= hpos
&& hpos
< hlinfo
->mouse_face_end_col
)
25055 else if ((vpos
== hlinfo
->mouse_face_beg_row
25056 && hpos
>= hlinfo
->mouse_face_beg_col
)
25057 || (vpos
== hlinfo
->mouse_face_end_row
25058 && hpos
< hlinfo
->mouse_face_end_col
))
25063 if (hlinfo
->mouse_face_beg_row
== hlinfo
->mouse_face_end_row
)
25065 if (hlinfo
->mouse_face_end_col
< hpos
&& hpos
<= hlinfo
->mouse_face_beg_col
)
25068 else if ((vpos
== hlinfo
->mouse_face_beg_row
25069 && hpos
<= hlinfo
->mouse_face_beg_col
)
25070 || (vpos
== hlinfo
->mouse_face_end_row
25071 && hpos
> hlinfo
->mouse_face_end_col
))
25079 Non-zero if physical cursor of window W is within mouse face. */
25082 cursor_in_mouse_face_p (struct window
*w
)
25084 return coords_in_mouse_face_p (w
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
);
25089 /* Find the glyph rows START_ROW and END_ROW of window W that display
25090 characters between buffer positions START_CHARPOS and END_CHARPOS
25091 (excluding END_CHARPOS). This is similar to row_containing_pos,
25092 but is more accurate when bidi reordering makes buffer positions
25093 change non-linearly with glyph rows. */
25095 rows_from_pos_range (struct window
*w
,
25096 EMACS_INT start_charpos
, EMACS_INT end_charpos
,
25097 struct glyph_row
**start
, struct glyph_row
**end
)
25099 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
25100 int last_y
= window_text_bottom_y (w
);
25101 struct glyph_row
*row
;
25106 while (!first
->enabled_p
25107 && first
< MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
))
25110 /* Find the START row. */
25112 row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
;
25115 /* A row can potentially be the START row if the range of the
25116 characters it displays intersects the range
25117 [START_CHARPOS..END_CHARPOS). */
25118 if (! ((start_charpos
< MATRIX_ROW_START_CHARPOS (row
)
25119 && end_charpos
< MATRIX_ROW_START_CHARPOS (row
))
25120 /* See the commentary in row_containing_pos, for the
25121 explanation of the complicated way to check whether
25122 some position is beyond the end of the characters
25123 displayed by a row. */
25124 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (row
)
25125 || (start_charpos
== MATRIX_ROW_END_CHARPOS (row
)
25126 && !row
->ends_at_zv_p
25127 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
)))
25128 && (end_charpos
> MATRIX_ROW_END_CHARPOS (row
)
25129 || (end_charpos
== MATRIX_ROW_END_CHARPOS (row
)
25130 && !row
->ends_at_zv_p
25131 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row
))))))
25133 /* Found a candidate row. Now make sure at least one of the
25134 glyphs it displays has a charpos from the range
25135 [START_CHARPOS..END_CHARPOS).
25137 This is not obvious because bidi reordering could make
25138 buffer positions of a row be 1,2,3,102,101,100, and if we
25139 want to highlight characters in [50..60), we don't want
25140 this row, even though [50..60) does intersect [1..103),
25141 the range of character positions given by the row's start
25142 and end positions. */
25143 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
25144 struct glyph
*e
= g
+ row
->used
[TEXT_AREA
];
25148 if (BUFFERP (g
->object
)
25149 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
25158 /* Find the END row. */
25160 /* If the last row is partially visible, start looking for END
25161 from that row, instead of starting from FIRST. */
25162 && !(row
->enabled_p
25163 && row
->y
< last_y
&& MATRIX_ROW_BOTTOM_Y (row
) > last_y
))
25165 for ( ; row
->enabled_p
&& MATRIX_ROW_BOTTOM_Y (row
) <= last_y
; row
++)
25167 struct glyph_row
*next
= row
+ 1;
25169 if (!next
->enabled_p
25170 || next
>= MATRIX_BOTTOM_TEXT_ROW (w
->current_matrix
, w
)
25171 /* The first row >= START whose range of displayed characters
25172 does NOT intersect the range [START_CHARPOS..END_CHARPOS]
25173 is the row END + 1. */
25174 || (start_charpos
< MATRIX_ROW_START_CHARPOS (next
)
25175 && end_charpos
< MATRIX_ROW_START_CHARPOS (next
))
25176 || ((start_charpos
> MATRIX_ROW_END_CHARPOS (next
)
25177 || (start_charpos
== MATRIX_ROW_END_CHARPOS (next
)
25178 && !next
->ends_at_zv_p
25179 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))
25180 && (end_charpos
> MATRIX_ROW_END_CHARPOS (next
)
25181 || (end_charpos
== MATRIX_ROW_END_CHARPOS (next
)
25182 && !next
->ends_at_zv_p
25183 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next
)))))
25190 /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
25191 but none of the characters it displays are in the range, it is
25193 struct glyph
*g
= next
->glyphs
[TEXT_AREA
];
25194 struct glyph
*e
= g
+ next
->used
[TEXT_AREA
];
25198 if (BUFFERP (g
->object
)
25199 && start_charpos
<= g
->charpos
&& g
->charpos
< end_charpos
)
25212 /* This function sets the mouse_face_* elements of HLINFO, assuming
25213 the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
25214 window WINDOW. START_CHARPOS and END_CHARPOS are buffer positions
25215 for the overlay or run of text properties specifying the mouse
25216 face. BEFORE_STRING and AFTER_STRING, if non-nil, are a
25217 before-string and after-string that must also be highlighted.
25218 COVER_STRING, if non-nil, is a display string that may cover some
25219 or all of the highlighted text. */
25222 mouse_face_from_buffer_pos (Lisp_Object window
,
25223 Mouse_HLInfo
*hlinfo
,
25224 EMACS_INT mouse_charpos
,
25225 EMACS_INT start_charpos
,
25226 EMACS_INT end_charpos
,
25227 Lisp_Object before_string
,
25228 Lisp_Object after_string
,
25229 Lisp_Object cover_string
)
25231 struct window
*w
= XWINDOW (window
);
25232 struct glyph_row
*first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
25233 struct glyph_row
*r1
, *r2
;
25234 struct glyph
*glyph
, *end
;
25235 EMACS_INT ignore
, pos
;
25238 xassert (NILP (cover_string
) || STRINGP (cover_string
));
25239 xassert (NILP (before_string
) || STRINGP (before_string
));
25240 xassert (NILP (after_string
) || STRINGP (after_string
));
25242 /* Find the rows corresponding to START_CHARPOS and END_CHARPOS. */
25243 rows_from_pos_range (w
, start_charpos
, end_charpos
, &r1
, &r2
);
25245 r1
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
25246 /* If the before-string or display-string contains newlines,
25247 rows_from_pos_range skips to its last row. Move back. */
25248 if (!NILP (before_string
) || !NILP (cover_string
))
25250 struct glyph_row
*prev
;
25251 while ((prev
= r1
- 1, prev
>= first
)
25252 && MATRIX_ROW_END_CHARPOS (prev
) == start_charpos
25253 && prev
->used
[TEXT_AREA
] > 0)
25255 struct glyph
*beg
= prev
->glyphs
[TEXT_AREA
];
25256 glyph
= beg
+ prev
->used
[TEXT_AREA
];
25257 while (--glyph
>= beg
&& INTEGERP (glyph
->object
));
25259 || !(EQ (glyph
->object
, before_string
)
25260 || EQ (glyph
->object
, cover_string
)))
25267 r2
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
25268 hlinfo
->mouse_face_past_end
= 1;
25270 else if (!NILP (after_string
))
25272 /* If the after-string has newlines, advance to its last row. */
25273 struct glyph_row
*next
;
25274 struct glyph_row
*last
25275 = MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
25277 for (next
= r2
+ 1;
25279 && next
->used
[TEXT_AREA
] > 0
25280 && EQ (next
->glyphs
[TEXT_AREA
]->object
, after_string
);
25284 /* The rest of the display engine assumes that mouse_face_beg_row is
25285 either above below mouse_face_end_row or identical to it. But
25286 with bidi-reordered continued lines, the row for START_CHARPOS
25287 could be below the row for END_CHARPOS. If so, swap the rows and
25288 store them in correct order. */
25291 struct glyph_row
*tem
= r2
;
25297 hlinfo
->mouse_face_beg_y
= r1
->y
;
25298 hlinfo
->mouse_face_beg_row
= MATRIX_ROW_VPOS (r1
, w
->current_matrix
);
25299 hlinfo
->mouse_face_end_y
= r2
->y
;
25300 hlinfo
->mouse_face_end_row
= MATRIX_ROW_VPOS (r2
, w
->current_matrix
);
25302 /* For a bidi-reordered row, the positions of BEFORE_STRING,
25303 AFTER_STRING, COVER_STRING, START_CHARPOS, and END_CHARPOS
25304 could be anywhere in the row and in any order. The strategy
25305 below is to find the leftmost and the rightmost glyph that
25306 belongs to either of these 3 strings, or whose position is
25307 between START_CHARPOS and END_CHARPOS, and highlight all the
25308 glyphs between those two. This may cover more than just the text
25309 between START_CHARPOS and END_CHARPOS if the range of characters
25310 strides the bidi level boundary, e.g. if the beginning is in R2L
25311 text while the end is in L2R text or vice versa. */
25312 if (!r1
->reversed_p
)
25314 /* This row is in a left to right paragraph. Scan it left to
25316 glyph
= r1
->glyphs
[TEXT_AREA
];
25317 end
= glyph
+ r1
->used
[TEXT_AREA
];
25320 /* Skip truncation glyphs at the start of the glyph row. */
25321 if (r1
->displays_text_p
)
25323 && INTEGERP (glyph
->object
)
25324 && glyph
->charpos
< 0;
25326 x
+= glyph
->pixel_width
;
25328 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
25329 or COVER_STRING, and the first glyph from buffer whose
25330 position is between START_CHARPOS and END_CHARPOS. */
25332 && !INTEGERP (glyph
->object
)
25333 && !EQ (glyph
->object
, cover_string
)
25334 && !(BUFFERP (glyph
->object
)
25335 && (glyph
->charpos
>= start_charpos
25336 && glyph
->charpos
< end_charpos
));
25339 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25340 are present at buffer positions between START_CHARPOS and
25341 END_CHARPOS, or if they come from an overlay. */
25342 if (EQ (glyph
->object
, before_string
))
25344 pos
= string_buffer_position (before_string
,
25346 /* If pos == 0, it means before_string came from an
25347 overlay, not from a buffer position. */
25348 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25351 else if (EQ (glyph
->object
, after_string
))
25353 pos
= string_buffer_position (after_string
, end_charpos
);
25354 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25357 x
+= glyph
->pixel_width
;
25359 hlinfo
->mouse_face_beg_x
= x
;
25360 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
25364 /* This row is in a right to left paragraph. Scan it right to
25368 end
= r1
->glyphs
[TEXT_AREA
] - 1;
25369 glyph
= end
+ r1
->used
[TEXT_AREA
];
25371 /* Skip truncation glyphs at the start of the glyph row. */
25372 if (r1
->displays_text_p
)
25374 && INTEGERP (glyph
->object
)
25375 && glyph
->charpos
< 0;
25379 /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
25380 or COVER_STRING, and the first glyph from buffer whose
25381 position is between START_CHARPOS and END_CHARPOS. */
25383 && !INTEGERP (glyph
->object
)
25384 && !EQ (glyph
->object
, cover_string
)
25385 && !(BUFFERP (glyph
->object
)
25386 && (glyph
->charpos
>= start_charpos
25387 && glyph
->charpos
< end_charpos
));
25390 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25391 are present at buffer positions between START_CHARPOS and
25392 END_CHARPOS, or if they come from an overlay. */
25393 if (EQ (glyph
->object
, before_string
))
25395 pos
= string_buffer_position (before_string
, start_charpos
);
25396 /* If pos == 0, it means before_string came from an
25397 overlay, not from a buffer position. */
25398 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25401 else if (EQ (glyph
->object
, after_string
))
25403 pos
= string_buffer_position (after_string
, end_charpos
);
25404 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25409 glyph
++; /* first glyph to the right of the highlighted area */
25410 for (g
= r1
->glyphs
[TEXT_AREA
], x
= r1
->x
; g
< glyph
; g
++)
25411 x
+= g
->pixel_width
;
25412 hlinfo
->mouse_face_beg_x
= x
;
25413 hlinfo
->mouse_face_beg_col
= glyph
- r1
->glyphs
[TEXT_AREA
];
25416 /* If the highlight ends in a different row, compute GLYPH and END
25417 for the end row. Otherwise, reuse the values computed above for
25418 the row where the highlight begins. */
25421 if (!r2
->reversed_p
)
25423 glyph
= r2
->glyphs
[TEXT_AREA
];
25424 end
= glyph
+ r2
->used
[TEXT_AREA
];
25429 end
= r2
->glyphs
[TEXT_AREA
] - 1;
25430 glyph
= end
+ r2
->used
[TEXT_AREA
];
25434 if (!r2
->reversed_p
)
25436 /* Skip truncation and continuation glyphs near the end of the
25437 row, and also blanks and stretch glyphs inserted by
25438 extend_face_to_end_of_line. */
25440 && INTEGERP ((end
- 1)->object
)
25441 && (end
- 1)->charpos
<= 0)
25443 /* Scan the rest of the glyph row from the end, looking for the
25444 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
25445 COVER_STRING, or whose position is between START_CHARPOS
25449 && !INTEGERP (end
->object
)
25450 && !EQ (end
->object
, cover_string
)
25451 && !(BUFFERP (end
->object
)
25452 && (end
->charpos
>= start_charpos
25453 && end
->charpos
< end_charpos
));
25456 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25457 are present at buffer positions between START_CHARPOS and
25458 END_CHARPOS, or if they come from an overlay. */
25459 if (EQ (end
->object
, before_string
))
25461 pos
= string_buffer_position (before_string
, start_charpos
);
25462 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25465 else if (EQ (end
->object
, after_string
))
25467 pos
= string_buffer_position (after_string
, end_charpos
);
25468 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25472 /* Find the X coordinate of the last glyph to be highlighted. */
25473 for (; glyph
<= end
; ++glyph
)
25474 x
+= glyph
->pixel_width
;
25476 hlinfo
->mouse_face_end_x
= x
;
25477 hlinfo
->mouse_face_end_col
= glyph
- r2
->glyphs
[TEXT_AREA
];
25481 /* Skip truncation and continuation glyphs near the end of the
25482 row, and also blanks and stretch glyphs inserted by
25483 extend_face_to_end_of_line. */
25487 && INTEGERP (end
->object
)
25488 && end
->charpos
<= 0)
25490 x
+= end
->pixel_width
;
25493 /* Scan the rest of the glyph row from the end, looking for the
25494 first glyph that comes from BEFORE_STRING, AFTER_STRING, or
25495 COVER_STRING, or whose position is between START_CHARPOS
25499 && !INTEGERP (end
->object
)
25500 && !EQ (end
->object
, cover_string
)
25501 && !(BUFFERP (end
->object
)
25502 && (end
->charpos
>= start_charpos
25503 && end
->charpos
< end_charpos
));
25506 /* BEFORE_STRING or AFTER_STRING are only relevant if they
25507 are present at buffer positions between START_CHARPOS and
25508 END_CHARPOS, or if they come from an overlay. */
25509 if (EQ (end
->object
, before_string
))
25511 pos
= string_buffer_position (before_string
, start_charpos
);
25512 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25515 else if (EQ (end
->object
, after_string
))
25517 pos
= string_buffer_position (after_string
, end_charpos
);
25518 if (!pos
|| (pos
>= start_charpos
&& pos
< end_charpos
))
25521 x
+= end
->pixel_width
;
25523 hlinfo
->mouse_face_end_x
= x
;
25524 hlinfo
->mouse_face_end_col
= end
- r2
->glyphs
[TEXT_AREA
];
25527 hlinfo
->mouse_face_window
= window
;
25528 hlinfo
->mouse_face_face_id
25529 = face_at_buffer_position (w
, mouse_charpos
, 0, 0, &ignore
,
25531 !hlinfo
->mouse_face_hidden
, -1);
25532 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
25535 /* The following function is not used anymore (replaced with
25536 mouse_face_from_string_pos), but I leave it here for the time
25537 being, in case someone would. */
25539 #if 0 /* not used */
25541 /* Find the position of the glyph for position POS in OBJECT in
25542 window W's current matrix, and return in *X, *Y the pixel
25543 coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
25545 RIGHT_P non-zero means return the position of the right edge of the
25546 glyph, RIGHT_P zero means return the left edge position.
25548 If no glyph for POS exists in the matrix, return the position of
25549 the glyph with the next smaller position that is in the matrix, if
25550 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
25551 exists in the matrix, return the position of the glyph with the
25552 next larger position in OBJECT.
25554 Value is non-zero if a glyph was found. */
25557 fast_find_string_pos (struct window
*w
, EMACS_INT pos
, Lisp_Object object
,
25558 int *hpos
, int *vpos
, int *x
, int *y
, int right_p
)
25560 int yb
= window_text_bottom_y (w
);
25561 struct glyph_row
*r
;
25562 struct glyph
*best_glyph
= NULL
;
25563 struct glyph_row
*best_row
= NULL
;
25566 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
25567 r
->enabled_p
&& r
->y
< yb
;
25570 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
25571 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
25574 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
25575 if (EQ (g
->object
, object
))
25577 if (g
->charpos
== pos
)
25584 else if (best_glyph
== NULL
25585 || ((eabs (g
->charpos
- pos
)
25586 < eabs (best_glyph
->charpos
- pos
))
25589 : g
->charpos
> pos
)))
25603 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
25607 *x
+= best_glyph
->pixel_width
;
25612 *vpos
= best_row
- w
->current_matrix
->rows
;
25615 return best_glyph
!= NULL
;
25617 #endif /* not used */
25619 /* Find the positions of the first and the last glyphs in window W's
25620 current matrix that occlude positions [STARTPOS..ENDPOS] in OBJECT
25621 (assumed to be a string), and return in HLINFO's mouse_face_*
25622 members the pixel and column/row coordinates of those glyphs. */
25625 mouse_face_from_string_pos (struct window
*w
, Mouse_HLInfo
*hlinfo
,
25626 Lisp_Object object
,
25627 EMACS_INT startpos
, EMACS_INT endpos
)
25629 int yb
= window_text_bottom_y (w
);
25630 struct glyph_row
*r
;
25631 struct glyph
*g
, *e
;
25635 /* Find the glyph row with at least one position in the range
25636 [STARTPOS..ENDPOS], and the first glyph in that row whose
25637 position belongs to that range. */
25638 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
25639 r
->enabled_p
&& r
->y
< yb
;
25642 if (!r
->reversed_p
)
25644 g
= r
->glyphs
[TEXT_AREA
];
25645 e
= g
+ r
->used
[TEXT_AREA
];
25646 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
25647 if (EQ (g
->object
, object
)
25648 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
25650 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
25651 hlinfo
->mouse_face_beg_y
= r
->y
;
25652 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
25653 hlinfo
->mouse_face_beg_x
= gx
;
25662 e
= r
->glyphs
[TEXT_AREA
];
25663 g
= e
+ r
->used
[TEXT_AREA
];
25664 for ( ; g
> e
; --g
)
25665 if (EQ ((g
-1)->object
, object
)
25666 && startpos
<= (g
-1)->charpos
&& (g
-1)->charpos
<= endpos
)
25668 hlinfo
->mouse_face_beg_row
= r
- w
->current_matrix
->rows
;
25669 hlinfo
->mouse_face_beg_y
= r
->y
;
25670 hlinfo
->mouse_face_beg_col
= g
- r
->glyphs
[TEXT_AREA
];
25671 for (gx
= r
->x
, g1
= r
->glyphs
[TEXT_AREA
]; g1
< g
; ++g1
)
25672 gx
+= g1
->pixel_width
;
25673 hlinfo
->mouse_face_beg_x
= gx
;
25685 /* Starting with the next row, look for the first row which does NOT
25686 include any glyphs whose positions are in the range. */
25687 for (++r
; r
->enabled_p
&& r
->y
< yb
; ++r
)
25689 g
= r
->glyphs
[TEXT_AREA
];
25690 e
= g
+ r
->used
[TEXT_AREA
];
25692 for ( ; g
< e
; ++g
)
25693 if (EQ (g
->object
, object
)
25694 && startpos
<= g
->charpos
&& g
->charpos
<= endpos
)
25703 /* The highlighted region ends on the previous row. */
25706 /* Set the end row and its vertical pixel coordinate. */
25707 hlinfo
->mouse_face_end_row
= r
- w
->current_matrix
->rows
;
25708 hlinfo
->mouse_face_end_y
= r
->y
;
25710 /* Compute and set the end column and the end column's horizontal
25711 pixel coordinate. */
25712 if (!r
->reversed_p
)
25714 g
= r
->glyphs
[TEXT_AREA
];
25715 e
= g
+ r
->used
[TEXT_AREA
];
25716 for ( ; e
> g
; --e
)
25717 if (EQ ((e
-1)->object
, object
)
25718 && startpos
<= (e
-1)->charpos
&& (e
-1)->charpos
<= endpos
)
25720 hlinfo
->mouse_face_end_col
= e
- g
;
25722 for (gx
= r
->x
; g
< e
; ++g
)
25723 gx
+= g
->pixel_width
;
25724 hlinfo
->mouse_face_end_x
= gx
;
25728 e
= r
->glyphs
[TEXT_AREA
];
25729 g
= e
+ r
->used
[TEXT_AREA
];
25730 for (gx
= r
->x
; e
< g
; ++e
)
25732 if (EQ (e
->object
, object
)
25733 && startpos
<= e
->charpos
&& e
->charpos
<= endpos
)
25735 gx
+= e
->pixel_width
;
25737 hlinfo
->mouse_face_end_col
= e
- r
->glyphs
[TEXT_AREA
];
25738 hlinfo
->mouse_face_end_x
= gx
;
25742 #ifdef HAVE_WINDOW_SYSTEM
25744 /* See if position X, Y is within a hot-spot of an image. */
25747 on_hot_spot_p (Lisp_Object hot_spot
, int x
, int y
)
25749 if (!CONSP (hot_spot
))
25752 if (EQ (XCAR (hot_spot
), Qrect
))
25754 /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1)) */
25755 Lisp_Object rect
= XCDR (hot_spot
);
25759 if (!CONSP (XCAR (rect
)))
25761 if (!CONSP (XCDR (rect
)))
25763 if (!(tem
= XCAR (XCAR (rect
)), INTEGERP (tem
) && x
>= XINT (tem
)))
25765 if (!(tem
= XCDR (XCAR (rect
)), INTEGERP (tem
) && y
>= XINT (tem
)))
25767 if (!(tem
= XCAR (XCDR (rect
)), INTEGERP (tem
) && x
<= XINT (tem
)))
25769 if (!(tem
= XCDR (XCDR (rect
)), INTEGERP (tem
) && y
<= XINT (tem
)))
25773 else if (EQ (XCAR (hot_spot
), Qcircle
))
25775 /* CDR is (Center . Radius) = ((x0 . y0) . r) */
25776 Lisp_Object circ
= XCDR (hot_spot
);
25777 Lisp_Object lr
, lx0
, ly0
;
25779 && CONSP (XCAR (circ
))
25780 && (lr
= XCDR (circ
), INTEGERP (lr
) || FLOATP (lr
))
25781 && (lx0
= XCAR (XCAR (circ
)), INTEGERP (lx0
))
25782 && (ly0
= XCDR (XCAR (circ
)), INTEGERP (ly0
)))
25784 double r
= XFLOATINT (lr
);
25785 double dx
= XINT (lx0
) - x
;
25786 double dy
= XINT (ly0
) - y
;
25787 return (dx
* dx
+ dy
* dy
<= r
* r
);
25790 else if (EQ (XCAR (hot_spot
), Qpoly
))
25792 /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
25793 if (VECTORP (XCDR (hot_spot
)))
25795 struct Lisp_Vector
*v
= XVECTOR (XCDR (hot_spot
));
25796 Lisp_Object
*poly
= v
->contents
;
25797 int n
= v
->header
.size
;
25800 Lisp_Object lx
, ly
;
25803 /* Need an even number of coordinates, and at least 3 edges. */
25804 if (n
< 6 || n
& 1)
25807 /* Count edge segments intersecting line from (X,Y) to (X,infinity).
25808 If count is odd, we are inside polygon. Pixels on edges
25809 may or may not be included depending on actual geometry of the
25811 if ((lx
= poly
[n
-2], !INTEGERP (lx
))
25812 || (ly
= poly
[n
-1], !INTEGERP (lx
)))
25814 x0
= XINT (lx
), y0
= XINT (ly
);
25815 for (i
= 0; i
< n
; i
+= 2)
25817 int x1
= x0
, y1
= y0
;
25818 if ((lx
= poly
[i
], !INTEGERP (lx
))
25819 || (ly
= poly
[i
+1], !INTEGERP (ly
)))
25821 x0
= XINT (lx
), y0
= XINT (ly
);
25823 /* Does this segment cross the X line? */
25831 if (y
> y0
&& y
> y1
)
25833 if (y
< y0
+ ((y1
- y0
) * (x
- x0
)) / (x1
- x0
))
25843 find_hot_spot (Lisp_Object map
, int x
, int y
)
25845 while (CONSP (map
))
25847 if (CONSP (XCAR (map
))
25848 && on_hot_spot_p (XCAR (XCAR (map
)), x
, y
))
25856 DEFUN ("lookup-image-map", Flookup_image_map
, Slookup_image_map
,
25858 doc
: /* Lookup in image map MAP coordinates X and Y.
25859 An image map is an alist where each element has the format (AREA ID PLIST).
25860 An AREA is specified as either a rectangle, a circle, or a polygon:
25861 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
25862 pixel coordinates of the upper left and bottom right corners.
25863 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
25864 and the radius of the circle; r may be a float or integer.
25865 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
25866 vector describes one corner in the polygon.
25867 Returns the alist element for the first matching AREA in MAP. */)
25868 (Lisp_Object map
, Lisp_Object x
, Lisp_Object y
)
25876 return find_hot_spot (map
, XINT (x
), XINT (y
));
25880 /* Display frame CURSOR, optionally using shape defined by POINTER. */
25882 define_frame_cursor1 (struct frame
*f
, Cursor cursor
, Lisp_Object pointer
)
25884 /* Do not change cursor shape while dragging mouse. */
25885 if (!NILP (do_mouse_tracking
))
25888 if (!NILP (pointer
))
25890 if (EQ (pointer
, Qarrow
))
25891 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25892 else if (EQ (pointer
, Qhand
))
25893 cursor
= FRAME_X_OUTPUT (f
)->hand_cursor
;
25894 else if (EQ (pointer
, Qtext
))
25895 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
25896 else if (EQ (pointer
, intern ("hdrag")))
25897 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
25898 #ifdef HAVE_X_WINDOWS
25899 else if (EQ (pointer
, intern ("vdrag")))
25900 cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
25902 else if (EQ (pointer
, intern ("hourglass")))
25903 cursor
= FRAME_X_OUTPUT (f
)->hourglass_cursor
;
25904 else if (EQ (pointer
, Qmodeline
))
25905 cursor
= FRAME_X_OUTPUT (f
)->modeline_cursor
;
25907 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
25910 if (cursor
!= No_Cursor
)
25911 FRAME_RIF (f
)->define_frame_cursor (f
, cursor
);
25914 #endif /* HAVE_WINDOW_SYSTEM */
25916 /* Take proper action when mouse has moved to the mode or header line
25917 or marginal area AREA of window W, x-position X and y-position Y.
25918 X is relative to the start of the text display area of W, so the
25919 width of bitmap areas and scroll bars must be subtracted to get a
25920 position relative to the start of the mode line. */
25923 note_mode_line_or_margin_highlight (Lisp_Object window
, int x
, int y
,
25924 enum window_part area
)
25926 struct window
*w
= XWINDOW (window
);
25927 struct frame
*f
= XFRAME (w
->frame
);
25928 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
25929 #ifdef HAVE_WINDOW_SYSTEM
25930 Display_Info
*dpyinfo
;
25932 Cursor cursor
= No_Cursor
;
25933 Lisp_Object pointer
= Qnil
;
25934 int dx
, dy
, width
, height
;
25936 Lisp_Object string
, object
= Qnil
;
25937 Lisp_Object pos
, help
;
25939 Lisp_Object mouse_face
;
25940 int original_x_pixel
= x
;
25941 struct glyph
* glyph
= NULL
, * row_start_glyph
= NULL
;
25942 struct glyph_row
*row
;
25944 if (area
== ON_MODE_LINE
|| area
== ON_HEADER_LINE
)
25949 /* Kludge alert: mode_line_string takes X/Y in pixels, but
25950 returns them in row/column units! */
25951 string
= mode_line_string (w
, area
, &x
, &y
, &charpos
,
25952 &object
, &dx
, &dy
, &width
, &height
);
25954 row
= (area
== ON_MODE_LINE
25955 ? MATRIX_MODE_LINE_ROW (w
->current_matrix
)
25956 : MATRIX_HEADER_LINE_ROW (w
->current_matrix
));
25958 /* Find the glyph under the mouse pointer. */
25959 if (row
->mode_line_p
&& row
->enabled_p
)
25961 glyph
= row_start_glyph
= row
->glyphs
[TEXT_AREA
];
25962 end
= glyph
+ row
->used
[TEXT_AREA
];
25964 for (x0
= original_x_pixel
;
25965 glyph
< end
&& x0
>= glyph
->pixel_width
;
25967 x0
-= glyph
->pixel_width
;
25975 x
-= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
);
25976 /* Kludge alert: marginal_area_string takes X/Y in pixels, but
25977 returns them in row/column units! */
25978 string
= marginal_area_string (w
, area
, &x
, &y
, &charpos
,
25979 &object
, &dx
, &dy
, &width
, &height
);
25984 #ifdef HAVE_WINDOW_SYSTEM
25985 if (IMAGEP (object
))
25987 Lisp_Object image_map
, hotspot
;
25988 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
25990 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
25992 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
25996 /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
25997 If so, we could look for mouse-enter, mouse-leave
25998 properties in PLIST (and do something...). */
25999 hotspot
= XCDR (hotspot
);
26000 if (CONSP (hotspot
)
26001 && (plist
= XCAR (hotspot
), CONSP (plist
)))
26003 pointer
= Fplist_get (plist
, Qpointer
);
26004 if (NILP (pointer
))
26006 help
= Fplist_get (plist
, Qhelp_echo
);
26009 help_echo_string
= help
;
26010 /* Is this correct? ++kfs */
26011 XSETWINDOW (help_echo_window
, w
);
26012 help_echo_object
= w
->buffer
;
26013 help_echo_pos
= charpos
;
26017 if (NILP (pointer
))
26018 pointer
= Fplist_get (XCDR (object
), QCpointer
);
26020 #endif /* HAVE_WINDOW_SYSTEM */
26022 if (STRINGP (string
))
26024 pos
= make_number (charpos
);
26025 /* If we're on a string with `help-echo' text property, arrange
26026 for the help to be displayed. This is done by setting the
26027 global variable help_echo_string to the help string. */
26030 help
= Fget_text_property (pos
, Qhelp_echo
, string
);
26033 help_echo_string
= help
;
26034 XSETWINDOW (help_echo_window
, w
);
26035 help_echo_object
= string
;
26036 help_echo_pos
= charpos
;
26040 #ifdef HAVE_WINDOW_SYSTEM
26041 if (FRAME_WINDOW_P (f
))
26043 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
26044 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
26045 if (NILP (pointer
))
26046 pointer
= Fget_text_property (pos
, Qpointer
, string
);
26048 /* Change the mouse pointer according to what is under X/Y. */
26050 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
)))
26053 map
= Fget_text_property (pos
, Qlocal_map
, string
);
26054 if (!KEYMAPP (map
))
26055 map
= Fget_text_property (pos
, Qkeymap
, string
);
26056 if (!KEYMAPP (map
))
26057 cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
26062 /* Change the mouse face according to what is under X/Y. */
26063 mouse_face
= Fget_text_property (pos
, Qmouse_face
, string
);
26064 if (!NILP (mouse_face
)
26065 && ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
26070 struct glyph
* tmp_glyph
;
26074 int total_pixel_width
;
26075 EMACS_INT begpos
, endpos
, ignore
;
26079 b
= Fprevious_single_property_change (make_number (charpos
+ 1),
26080 Qmouse_face
, string
, Qnil
);
26086 e
= Fnext_single_property_change (pos
, Qmouse_face
, string
, Qnil
);
26088 endpos
= SCHARS (string
);
26092 /* Calculate the glyph position GPOS of GLYPH in the
26093 displayed string, relative to the beginning of the
26094 highlighted part of the string.
26096 Note: GPOS is different from CHARPOS. CHARPOS is the
26097 position of GLYPH in the internal string object. A mode
26098 line string format has structures which are converted to
26099 a flattened string by the Emacs Lisp interpreter. The
26100 internal string is an element of those structures. The
26101 displayed string is the flattened string. */
26102 tmp_glyph
= row_start_glyph
;
26103 while (tmp_glyph
< glyph
26104 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
26105 && begpos
<= tmp_glyph
->charpos
26106 && tmp_glyph
->charpos
< endpos
)))
26108 gpos
= glyph
- tmp_glyph
;
26110 /* Calculate the length GSEQ_LENGTH of the glyph sequence of
26111 the highlighted part of the displayed string to which
26112 GLYPH belongs. Note: GSEQ_LENGTH is different from
26113 SCHARS (STRING), because the latter returns the length of
26114 the internal string. */
26115 for (tmp_glyph
= row
->glyphs
[TEXT_AREA
] + row
->used
[TEXT_AREA
] - 1;
26117 && (!(EQ (tmp_glyph
->object
, glyph
->object
)
26118 && begpos
<= tmp_glyph
->charpos
26119 && tmp_glyph
->charpos
< endpos
));
26122 gseq_length
= gpos
+ (tmp_glyph
- glyph
) + 1;
26124 /* Calculate the total pixel width of all the glyphs between
26125 the beginning of the highlighted area and GLYPH. */
26126 total_pixel_width
= 0;
26127 for (tmp_glyph
= glyph
- gpos
; tmp_glyph
!= glyph
; tmp_glyph
++)
26128 total_pixel_width
+= tmp_glyph
->pixel_width
;
26130 /* Pre calculation of re-rendering position. Note: X is in
26131 column units here, after the call to mode_line_string or
26132 marginal_area_string. */
26134 vpos
= (area
== ON_MODE_LINE
26135 ? (w
->current_matrix
)->nrows
- 1
26138 /* If GLYPH's position is included in the region that is
26139 already drawn in mouse face, we have nothing to do. */
26140 if ( EQ (window
, hlinfo
->mouse_face_window
)
26141 && (!row
->reversed_p
26142 ? (hlinfo
->mouse_face_beg_col
<= hpos
26143 && hpos
< hlinfo
->mouse_face_end_col
)
26144 /* In R2L rows we swap BEG and END, see below. */
26145 : (hlinfo
->mouse_face_end_col
<= hpos
26146 && hpos
< hlinfo
->mouse_face_beg_col
))
26147 && hlinfo
->mouse_face_beg_row
== vpos
)
26150 if (clear_mouse_face (hlinfo
))
26151 cursor
= No_Cursor
;
26153 if (!row
->reversed_p
)
26155 hlinfo
->mouse_face_beg_col
= hpos
;
26156 hlinfo
->mouse_face_beg_x
= original_x_pixel
26157 - (total_pixel_width
+ dx
);
26158 hlinfo
->mouse_face_end_col
= hpos
+ gseq_length
;
26159 hlinfo
->mouse_face_end_x
= 0;
26163 /* In R2L rows, show_mouse_face expects BEG and END
26164 coordinates to be swapped. */
26165 hlinfo
->mouse_face_end_col
= hpos
;
26166 hlinfo
->mouse_face_end_x
= original_x_pixel
26167 - (total_pixel_width
+ dx
);
26168 hlinfo
->mouse_face_beg_col
= hpos
+ gseq_length
;
26169 hlinfo
->mouse_face_beg_x
= 0;
26172 hlinfo
->mouse_face_beg_row
= vpos
;
26173 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_beg_row
;
26174 hlinfo
->mouse_face_beg_y
= 0;
26175 hlinfo
->mouse_face_end_y
= 0;
26176 hlinfo
->mouse_face_past_end
= 0;
26177 hlinfo
->mouse_face_window
= window
;
26179 hlinfo
->mouse_face_face_id
= face_at_string_position (w
, string
,
26185 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
26187 if (NILP (pointer
))
26190 else if ((area
== ON_MODE_LINE
) || (area
== ON_HEADER_LINE
))
26191 clear_mouse_face (hlinfo
);
26193 #ifdef HAVE_WINDOW_SYSTEM
26194 if (FRAME_WINDOW_P (f
))
26195 define_frame_cursor1 (f
, cursor
, pointer
);
26201 Take proper action when the mouse has moved to position X, Y on
26202 frame F as regards highlighting characters that have mouse-face
26203 properties. Also de-highlighting chars where the mouse was before.
26204 X and Y can be negative or out of range. */
26207 note_mouse_highlight (struct frame
*f
, int x
, int y
)
26209 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
26210 enum window_part part
;
26211 Lisp_Object window
;
26213 Cursor cursor
= No_Cursor
;
26214 Lisp_Object pointer
= Qnil
; /* Takes precedence over cursor! */
26217 /* When a menu is active, don't highlight because this looks odd. */
26218 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (MSDOS)
26219 if (popup_activated ())
26223 if (NILP (Vmouse_highlight
)
26224 || !f
->glyphs_initialized_p
26225 || f
->pointer_invisible
)
26228 hlinfo
->mouse_face_mouse_x
= x
;
26229 hlinfo
->mouse_face_mouse_y
= y
;
26230 hlinfo
->mouse_face_mouse_frame
= f
;
26232 if (hlinfo
->mouse_face_defer
)
26235 if (gc_in_progress
)
26237 hlinfo
->mouse_face_deferred_gc
= 1;
26241 /* Which window is that in? */
26242 window
= window_from_coordinates (f
, x
, y
, &part
, 1);
26244 /* If we were displaying active text in another window, clear that.
26245 Also clear if we move out of text area in same window. */
26246 if (! EQ (window
, hlinfo
->mouse_face_window
)
26247 || (part
!= ON_TEXT
&& part
!= ON_MODE_LINE
&& part
!= ON_HEADER_LINE
26248 && !NILP (hlinfo
->mouse_face_window
)))
26249 clear_mouse_face (hlinfo
);
26251 /* Not on a window -> return. */
26252 if (!WINDOWP (window
))
26255 /* Reset help_echo_string. It will get recomputed below. */
26256 help_echo_string
= Qnil
;
26258 /* Convert to window-relative pixel coordinates. */
26259 w
= XWINDOW (window
);
26260 frame_to_window_pixel_xy (w
, &x
, &y
);
26262 #ifdef HAVE_WINDOW_SYSTEM
26263 /* Handle tool-bar window differently since it doesn't display a
26265 if (EQ (window
, f
->tool_bar_window
))
26267 note_tool_bar_highlight (f
, x
, y
);
26272 /* Mouse is on the mode, header line or margin? */
26273 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
26274 || part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
26276 note_mode_line_or_margin_highlight (window
, x
, y
, part
);
26280 #ifdef HAVE_WINDOW_SYSTEM
26281 if (part
== ON_VERTICAL_BORDER
)
26283 cursor
= FRAME_X_OUTPUT (f
)->horizontal_drag_cursor
;
26284 help_echo_string
= build_string ("drag-mouse-1: resize");
26286 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
26287 || part
== ON_SCROLL_BAR
)
26288 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
26290 cursor
= FRAME_X_OUTPUT (f
)->text_cursor
;
26293 /* Are we in a window whose display is up to date?
26294 And verify the buffer's text has not changed. */
26295 b
= XBUFFER (w
->buffer
);
26296 if (part
== ON_TEXT
26297 && EQ (w
->window_end_valid
, w
->buffer
)
26298 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
26299 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
26301 int hpos
, vpos
, i
, dx
, dy
, area
;
26303 struct glyph
*glyph
;
26304 Lisp_Object object
;
26305 Lisp_Object mouse_face
= Qnil
, position
;
26306 Lisp_Object
*overlay_vec
= NULL
;
26308 struct buffer
*obuf
;
26309 EMACS_INT obegv
, ozv
;
26312 /* Find the glyph under X/Y. */
26313 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &dx
, &dy
, &area
);
26315 #ifdef HAVE_WINDOW_SYSTEM
26316 /* Look for :pointer property on image. */
26317 if (glyph
!= NULL
&& glyph
->type
== IMAGE_GLYPH
)
26319 struct image
*img
= IMAGE_FROM_ID (f
, glyph
->u
.img_id
);
26320 if (img
!= NULL
&& IMAGEP (img
->spec
))
26322 Lisp_Object image_map
, hotspot
;
26323 if ((image_map
= Fplist_get (XCDR (img
->spec
), QCmap
),
26325 && (hotspot
= find_hot_spot (image_map
,
26326 glyph
->slice
.img
.x
+ dx
,
26327 glyph
->slice
.img
.y
+ dy
),
26329 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
26333 /* Could check XCAR (hotspot) to see if we enter/leave
26335 If so, we could look for mouse-enter, mouse-leave
26336 properties in PLIST (and do something...). */
26337 hotspot
= XCDR (hotspot
);
26338 if (CONSP (hotspot
)
26339 && (plist
= XCAR (hotspot
), CONSP (plist
)))
26341 pointer
= Fplist_get (plist
, Qpointer
);
26342 if (NILP (pointer
))
26344 help_echo_string
= Fplist_get (plist
, Qhelp_echo
);
26345 if (!NILP (help_echo_string
))
26347 help_echo_window
= window
;
26348 help_echo_object
= glyph
->object
;
26349 help_echo_pos
= glyph
->charpos
;
26353 if (NILP (pointer
))
26354 pointer
= Fplist_get (XCDR (img
->spec
), QCpointer
);
26357 #endif /* HAVE_WINDOW_SYSTEM */
26359 /* Clear mouse face if X/Y not over text. */
26361 || area
!= TEXT_AREA
26362 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
26363 /* Glyph's OBJECT is an integer for glyphs inserted by the
26364 display engine for its internal purposes, like truncation
26365 and continuation glyphs and blanks beyond the end of
26366 line's text on text terminals. If we are over such a
26367 glyph, we are not over any text. */
26368 || INTEGERP (glyph
->object
)
26369 /* R2L rows have a stretch glyph at their front, which
26370 stands for no text, whereas L2R rows have no glyphs at
26371 all beyond the end of text. Treat such stretch glyphs
26372 like we do with NULL glyphs in L2R rows. */
26373 || (MATRIX_ROW (w
->current_matrix
, vpos
)->reversed_p
26374 && glyph
== MATRIX_ROW (w
->current_matrix
, vpos
)->glyphs
[TEXT_AREA
]
26375 && glyph
->type
== STRETCH_GLYPH
26376 && glyph
->avoid_cursor_p
))
26378 if (clear_mouse_face (hlinfo
))
26379 cursor
= No_Cursor
;
26380 #ifdef HAVE_WINDOW_SYSTEM
26381 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
26383 if (area
!= TEXT_AREA
)
26384 cursor
= FRAME_X_OUTPUT (f
)->nontext_cursor
;
26386 pointer
= Vvoid_text_area_pointer
;
26392 pos
= glyph
->charpos
;
26393 object
= glyph
->object
;
26394 if (!STRINGP (object
) && !BUFFERP (object
))
26397 /* If we get an out-of-range value, return now; avoid an error. */
26398 if (BUFFERP (object
) && pos
> BUF_Z (b
))
26401 /* Make the window's buffer temporarily current for
26402 overlays_at and compute_char_face. */
26403 obuf
= current_buffer
;
26404 current_buffer
= b
;
26410 /* Is this char mouse-active or does it have help-echo? */
26411 position
= make_number (pos
);
26413 if (BUFFERP (object
))
26415 /* Put all the overlays we want in a vector in overlay_vec. */
26416 GET_OVERLAYS_AT (pos
, overlay_vec
, noverlays
, NULL
, 0);
26417 /* Sort overlays into increasing priority order. */
26418 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
26423 same_region
= coords_in_mouse_face_p (w
, hpos
, vpos
);
26426 cursor
= No_Cursor
;
26428 /* Check mouse-face highlighting. */
26430 /* If there exists an overlay with mouse-face overlapping
26431 the one we are currently highlighting, we have to
26432 check if we enter the overlapping overlay, and then
26433 highlight only that. */
26434 || (OVERLAYP (hlinfo
->mouse_face_overlay
)
26435 && mouse_face_overlay_overlaps (hlinfo
->mouse_face_overlay
)))
26437 /* Find the highest priority overlay with a mouse-face. */
26438 Lisp_Object overlay
= Qnil
;
26439 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
26441 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
26442 if (!NILP (mouse_face
))
26443 overlay
= overlay_vec
[i
];
26446 /* If we're highlighting the same overlay as before, there's
26447 no need to do that again. */
26448 if (!NILP (overlay
) && EQ (overlay
, hlinfo
->mouse_face_overlay
))
26449 goto check_help_echo
;
26450 hlinfo
->mouse_face_overlay
= overlay
;
26452 /* Clear the display of the old active region, if any. */
26453 if (clear_mouse_face (hlinfo
))
26454 cursor
= No_Cursor
;
26456 /* If no overlay applies, get a text property. */
26457 if (NILP (overlay
))
26458 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
26460 /* Next, compute the bounds of the mouse highlighting and
26462 if (!NILP (mouse_face
) && STRINGP (object
))
26464 /* The mouse-highlighting comes from a display string
26465 with a mouse-face. */
26469 s
= Fprevious_single_property_change
26470 (make_number (pos
+ 1), Qmouse_face
, object
, Qnil
);
26471 e
= Fnext_single_property_change
26472 (position
, Qmouse_face
, object
, Qnil
);
26474 s
= make_number (0);
26476 e
= make_number (SCHARS (object
) - 1);
26477 mouse_face_from_string_pos (w
, hlinfo
, object
,
26478 XINT (s
), XINT (e
));
26479 hlinfo
->mouse_face_past_end
= 0;
26480 hlinfo
->mouse_face_window
= window
;
26481 hlinfo
->mouse_face_face_id
26482 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
26483 glyph
->face_id
, 1);
26484 show_mouse_face (hlinfo
, DRAW_MOUSE_FACE
);
26485 cursor
= No_Cursor
;
26489 /* The mouse-highlighting, if any, comes from an overlay
26490 or text property in the buffer. */
26491 Lisp_Object buffer
IF_LINT (= Qnil
);
26492 Lisp_Object cover_string
IF_LINT (= Qnil
);
26494 if (STRINGP (object
))
26496 /* If we are on a display string with no mouse-face,
26497 check if the text under it has one. */
26498 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
26499 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
26500 pos
= string_buffer_position (object
, start
);
26503 mouse_face
= get_char_property_and_overlay
26504 (make_number (pos
), Qmouse_face
, w
->buffer
, &overlay
);
26505 buffer
= w
->buffer
;
26506 cover_string
= object
;
26512 cover_string
= Qnil
;
26515 if (!NILP (mouse_face
))
26517 Lisp_Object before
, after
;
26518 Lisp_Object before_string
, after_string
;
26519 /* To correctly find the limits of mouse highlight
26520 in a bidi-reordered buffer, we must not use the
26521 optimization of limiting the search in
26522 previous-single-property-change and
26523 next-single-property-change, because
26524 rows_from_pos_range needs the real start and end
26525 positions to DTRT in this case. That's because
26526 the first row visible in a window does not
26527 necessarily display the character whose position
26528 is the smallest. */
26530 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
26531 ? Fmarker_position (w
->start
)
26534 NILP (BVAR (XBUFFER (buffer
), bidi_display_reordering
))
26535 ? make_number (BUF_Z (XBUFFER (buffer
))
26536 - XFASTINT (w
->window_end_pos
))
26539 if (NILP (overlay
))
26541 /* Handle the text property case. */
26542 before
= Fprevious_single_property_change
26543 (make_number (pos
+ 1), Qmouse_face
, buffer
, lim1
);
26544 after
= Fnext_single_property_change
26545 (make_number (pos
), Qmouse_face
, buffer
, lim2
);
26546 before_string
= after_string
= Qnil
;
26550 /* Handle the overlay case. */
26551 before
= Foverlay_start (overlay
);
26552 after
= Foverlay_end (overlay
);
26553 before_string
= Foverlay_get (overlay
, Qbefore_string
);
26554 after_string
= Foverlay_get (overlay
, Qafter_string
);
26556 if (!STRINGP (before_string
)) before_string
= Qnil
;
26557 if (!STRINGP (after_string
)) after_string
= Qnil
;
26560 mouse_face_from_buffer_pos (window
, hlinfo
, pos
,
26563 before_string
, after_string
,
26565 cursor
= No_Cursor
;
26572 /* Look for a `help-echo' property. */
26573 if (NILP (help_echo_string
)) {
26574 Lisp_Object help
, overlay
;
26576 /* Check overlays first. */
26577 help
= overlay
= Qnil
;
26578 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
26580 overlay
= overlay_vec
[i
];
26581 help
= Foverlay_get (overlay
, Qhelp_echo
);
26586 help_echo_string
= help
;
26587 help_echo_window
= window
;
26588 help_echo_object
= overlay
;
26589 help_echo_pos
= pos
;
26593 Lisp_Object obj
= glyph
->object
;
26594 EMACS_INT charpos
= glyph
->charpos
;
26596 /* Try text properties. */
26599 && charpos
< SCHARS (obj
))
26601 help
= Fget_text_property (make_number (charpos
),
26605 /* If the string itself doesn't specify a help-echo,
26606 see if the buffer text ``under'' it does. */
26607 struct glyph_row
*r
26608 = MATRIX_ROW (w
->current_matrix
, vpos
);
26609 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
26610 EMACS_INT p
= string_buffer_position (obj
, start
);
26613 help
= Fget_char_property (make_number (p
),
26614 Qhelp_echo
, w
->buffer
);
26623 else if (BUFFERP (obj
)
26626 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
26631 help_echo_string
= help
;
26632 help_echo_window
= window
;
26633 help_echo_object
= obj
;
26634 help_echo_pos
= charpos
;
26639 #ifdef HAVE_WINDOW_SYSTEM
26640 /* Look for a `pointer' property. */
26641 if (FRAME_WINDOW_P (f
) && NILP (pointer
))
26643 /* Check overlays first. */
26644 for (i
= noverlays
- 1; i
>= 0 && NILP (pointer
); --i
)
26645 pointer
= Foverlay_get (overlay_vec
[i
], Qpointer
);
26647 if (NILP (pointer
))
26649 Lisp_Object obj
= glyph
->object
;
26650 EMACS_INT charpos
= glyph
->charpos
;
26652 /* Try text properties. */
26655 && charpos
< SCHARS (obj
))
26657 pointer
= Fget_text_property (make_number (charpos
),
26659 if (NILP (pointer
))
26661 /* If the string itself doesn't specify a pointer,
26662 see if the buffer text ``under'' it does. */
26663 struct glyph_row
*r
26664 = MATRIX_ROW (w
->current_matrix
, vpos
);
26665 EMACS_INT start
= MATRIX_ROW_START_CHARPOS (r
);
26666 EMACS_INT p
= string_buffer_position (obj
, start
);
26668 pointer
= Fget_char_property (make_number (p
),
26669 Qpointer
, w
->buffer
);
26672 else if (BUFFERP (obj
)
26675 pointer
= Fget_text_property (make_number (charpos
),
26679 #endif /* HAVE_WINDOW_SYSTEM */
26683 current_buffer
= obuf
;
26688 #ifdef HAVE_WINDOW_SYSTEM
26689 if (FRAME_WINDOW_P (f
))
26690 define_frame_cursor1 (f
, cursor
, pointer
);
26692 /* This is here to prevent a compiler error, about "label at end of
26693 compound statement". */
26700 Clear any mouse-face on window W. This function is part of the
26701 redisplay interface, and is called from try_window_id and similar
26702 functions to ensure the mouse-highlight is off. */
26705 x_clear_window_mouse_face (struct window
*w
)
26707 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
26708 Lisp_Object window
;
26711 XSETWINDOW (window
, w
);
26712 if (EQ (window
, hlinfo
->mouse_face_window
))
26713 clear_mouse_face (hlinfo
);
26719 Just discard the mouse face information for frame F, if any.
26720 This is used when the size of F is changed. */
26723 cancel_mouse_face (struct frame
*f
)
26725 Lisp_Object window
;
26726 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
26728 window
= hlinfo
->mouse_face_window
;
26729 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
26731 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
26732 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
26733 hlinfo
->mouse_face_window
= Qnil
;
26739 /***********************************************************************
26741 ***********************************************************************/
26743 #ifdef HAVE_WINDOW_SYSTEM
26745 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
26746 which intersects rectangle R. R is in window-relative coordinates. */
26749 expose_area (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
,
26750 enum glyph_row_area area
)
26752 struct glyph
*first
= row
->glyphs
[area
];
26753 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
26754 struct glyph
*last
;
26755 int first_x
, start_x
, x
;
26757 if (area
== TEXT_AREA
&& row
->fill_line_p
)
26758 /* If row extends face to end of line write the whole line. */
26759 draw_glyphs (w
, 0, row
, area
,
26760 0, row
->used
[area
],
26761 DRAW_NORMAL_TEXT
, 0);
26764 /* Set START_X to the window-relative start position for drawing glyphs of
26765 AREA. The first glyph of the text area can be partially visible.
26766 The first glyphs of other areas cannot. */
26767 start_x
= window_box_left_offset (w
, area
);
26769 if (area
== TEXT_AREA
)
26772 /* Find the first glyph that must be redrawn. */
26774 && x
+ first
->pixel_width
< r
->x
)
26776 x
+= first
->pixel_width
;
26780 /* Find the last one. */
26784 && x
< r
->x
+ r
->width
)
26786 x
+= last
->pixel_width
;
26792 draw_glyphs (w
, first_x
- start_x
, row
, area
,
26793 first
- row
->glyphs
[area
], last
- row
->glyphs
[area
],
26794 DRAW_NORMAL_TEXT
, 0);
26799 /* Redraw the parts of the glyph row ROW on window W intersecting
26800 rectangle R. R is in window-relative coordinates. Value is
26801 non-zero if mouse-face was overwritten. */
26804 expose_line (struct window
*w
, struct glyph_row
*row
, XRectangle
*r
)
26806 xassert (row
->enabled_p
);
26808 if (row
->mode_line_p
|| w
->pseudo_window_p
)
26809 draw_glyphs (w
, 0, row
, TEXT_AREA
,
26810 0, row
->used
[TEXT_AREA
],
26811 DRAW_NORMAL_TEXT
, 0);
26814 if (row
->used
[LEFT_MARGIN_AREA
])
26815 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
26816 if (row
->used
[TEXT_AREA
])
26817 expose_area (w
, row
, r
, TEXT_AREA
);
26818 if (row
->used
[RIGHT_MARGIN_AREA
])
26819 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
26820 draw_row_fringe_bitmaps (w
, row
);
26823 return row
->mouse_face_p
;
26827 /* Redraw those parts of glyphs rows during expose event handling that
26828 overlap other rows. Redrawing of an exposed line writes over parts
26829 of lines overlapping that exposed line; this function fixes that.
26831 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
26832 row in W's current matrix that is exposed and overlaps other rows.
26833 LAST_OVERLAPPING_ROW is the last such row. */
26836 expose_overlaps (struct window
*w
,
26837 struct glyph_row
*first_overlapping_row
,
26838 struct glyph_row
*last_overlapping_row
,
26841 struct glyph_row
*row
;
26843 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
26844 if (row
->overlapping_p
)
26846 xassert (row
->enabled_p
&& !row
->mode_line_p
);
26849 if (row
->used
[LEFT_MARGIN_AREA
])
26850 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, OVERLAPS_BOTH
);
26852 if (row
->used
[TEXT_AREA
])
26853 x_fix_overlapping_area (w
, row
, TEXT_AREA
, OVERLAPS_BOTH
);
26855 if (row
->used
[RIGHT_MARGIN_AREA
])
26856 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, OVERLAPS_BOTH
);
26862 /* Return non-zero if W's cursor intersects rectangle R. */
26865 phys_cursor_in_rect_p (struct window
*w
, XRectangle
*r
)
26867 XRectangle cr
, result
;
26868 struct glyph
*cursor_glyph
;
26869 struct glyph_row
*row
;
26871 if (w
->phys_cursor
.vpos
>= 0
26872 && w
->phys_cursor
.vpos
< w
->current_matrix
->nrows
26873 && (row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
),
26875 && row
->cursor_in_fringe_p
)
26877 /* Cursor is in the fringe. */
26878 cr
.x
= window_box_right_offset (w
,
26879 (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
26880 ? RIGHT_MARGIN_AREA
26883 cr
.width
= WINDOW_RIGHT_FRINGE_WIDTH (w
);
26884 cr
.height
= row
->height
;
26885 return x_intersect_rectangles (&cr
, r
, &result
);
26888 cursor_glyph
= get_phys_cursor_glyph (w
);
26891 /* r is relative to W's box, but w->phys_cursor.x is relative
26892 to left edge of W's TEXT area. Adjust it. */
26893 cr
.x
= window_box_left_offset (w
, TEXT_AREA
) + w
->phys_cursor
.x
;
26894 cr
.y
= w
->phys_cursor
.y
;
26895 cr
.width
= cursor_glyph
->pixel_width
;
26896 cr
.height
= w
->phys_cursor_height
;
26897 /* ++KFS: W32 version used W32-specific IntersectRect here, but
26898 I assume the effect is the same -- and this is portable. */
26899 return x_intersect_rectangles (&cr
, r
, &result
);
26901 /* If we don't understand the format, pretend we're not in the hot-spot. */
26907 Draw a vertical window border to the right of window W if W doesn't
26908 have vertical scroll bars. */
26911 x_draw_vertical_border (struct window
*w
)
26913 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
26915 /* We could do better, if we knew what type of scroll-bar the adjacent
26916 windows (on either side) have... But we don't :-(
26917 However, I think this works ok. ++KFS 2003-04-25 */
26919 /* Redraw borders between horizontally adjacent windows. Don't
26920 do it for frames with vertical scroll bars because either the
26921 right scroll bar of a window, or the left scroll bar of its
26922 neighbor will suffice as a border. */
26923 if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w
->frame
)))
26926 if (!WINDOW_RIGHTMOST_P (w
)
26927 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
26929 int x0
, x1
, y0
, y1
;
26931 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
26934 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
26937 FRAME_RIF (f
)->draw_vertical_window_border (w
, x1
, y0
, y1
);
26939 else if (!WINDOW_LEFTMOST_P (w
)
26940 && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
26942 int x0
, x1
, y0
, y1
;
26944 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
26947 if (WINDOW_LEFT_FRINGE_WIDTH (w
) == 0)
26950 FRAME_RIF (f
)->draw_vertical_window_border (w
, x0
, y0
, y1
);
26955 /* Redraw the part of window W intersection rectangle FR. Pixel
26956 coordinates in FR are frame-relative. Call this function with
26957 input blocked. Value is non-zero if the exposure overwrites
26961 expose_window (struct window
*w
, XRectangle
*fr
)
26963 struct frame
*f
= XFRAME (w
->frame
);
26965 int mouse_face_overwritten_p
= 0;
26967 /* If window is not yet fully initialized, do nothing. This can
26968 happen when toolkit scroll bars are used and a window is split.
26969 Reconfiguring the scroll bar will generate an expose for a newly
26971 if (w
->current_matrix
== NULL
)
26974 /* When we're currently updating the window, display and current
26975 matrix usually don't agree. Arrange for a thorough display
26977 if (w
== updated_window
)
26979 SET_FRAME_GARBAGED (f
);
26983 /* Frame-relative pixel rectangle of W. */
26984 wr
.x
= WINDOW_LEFT_EDGE_X (w
);
26985 wr
.y
= WINDOW_TOP_EDGE_Y (w
);
26986 wr
.width
= WINDOW_TOTAL_WIDTH (w
);
26987 wr
.height
= WINDOW_TOTAL_HEIGHT (w
);
26989 if (x_intersect_rectangles (fr
, &wr
, &r
))
26991 int yb
= window_text_bottom_y (w
);
26992 struct glyph_row
*row
;
26993 int cursor_cleared_p
;
26994 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
26996 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
26997 r
.x
, r
.y
, r
.width
, r
.height
));
26999 /* Convert to window coordinates. */
27000 r
.x
-= WINDOW_LEFT_EDGE_X (w
);
27001 r
.y
-= WINDOW_TOP_EDGE_Y (w
);
27003 /* Turn off the cursor. */
27004 if (!w
->pseudo_window_p
27005 && phys_cursor_in_rect_p (w
, &r
))
27007 x_clear_cursor (w
);
27008 cursor_cleared_p
= 1;
27011 cursor_cleared_p
= 0;
27013 /* Update lines intersecting rectangle R. */
27014 first_overlapping_row
= last_overlapping_row
= NULL
;
27015 for (row
= w
->current_matrix
->rows
;
27020 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
27022 if ((y0
>= r
.y
&& y0
< r
.y
+ r
.height
)
27023 || (y1
> r
.y
&& y1
< r
.y
+ r
.height
)
27024 || (r
.y
>= y0
&& r
.y
< y1
)
27025 || (r
.y
+ r
.height
> y0
&& r
.y
+ r
.height
< y1
))
27027 /* A header line may be overlapping, but there is no need
27028 to fix overlapping areas for them. KFS 2005-02-12 */
27029 if (row
->overlapping_p
&& !row
->mode_line_p
)
27031 if (first_overlapping_row
== NULL
)
27032 first_overlapping_row
= row
;
27033 last_overlapping_row
= row
;
27037 if (expose_line (w
, row
, &r
))
27038 mouse_face_overwritten_p
= 1;
27041 else if (row
->overlapping_p
)
27043 /* We must redraw a row overlapping the exposed area. */
27045 ? y0
+ row
->phys_height
> r
.y
27046 : y0
+ row
->ascent
- row
->phys_ascent
< r
.y
+r
.height
)
27048 if (first_overlapping_row
== NULL
)
27049 first_overlapping_row
= row
;
27050 last_overlapping_row
= row
;
27058 /* Display the mode line if there is one. */
27059 if (WINDOW_WANTS_MODELINE_P (w
)
27060 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
27062 && row
->y
< r
.y
+ r
.height
)
27064 if (expose_line (w
, row
, &r
))
27065 mouse_face_overwritten_p
= 1;
27068 if (!w
->pseudo_window_p
)
27070 /* Fix the display of overlapping rows. */
27071 if (first_overlapping_row
)
27072 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
,
27075 /* Draw border between windows. */
27076 x_draw_vertical_border (w
);
27078 /* Turn the cursor on again. */
27079 if (cursor_cleared_p
)
27080 update_window_cursor (w
, 1);
27084 return mouse_face_overwritten_p
;
27089 /* Redraw (parts) of all windows in the window tree rooted at W that
27090 intersect R. R contains frame pixel coordinates. Value is
27091 non-zero if the exposure overwrites mouse-face. */
27094 expose_window_tree (struct window
*w
, XRectangle
*r
)
27096 struct frame
*f
= XFRAME (w
->frame
);
27097 int mouse_face_overwritten_p
= 0;
27099 while (w
&& !FRAME_GARBAGED_P (f
))
27101 if (!NILP (w
->hchild
))
27102 mouse_face_overwritten_p
27103 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
27104 else if (!NILP (w
->vchild
))
27105 mouse_face_overwritten_p
27106 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
27108 mouse_face_overwritten_p
|= expose_window (w
, r
);
27110 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
27113 return mouse_face_overwritten_p
;
27118 Redisplay an exposed area of frame F. X and Y are the upper-left
27119 corner of the exposed rectangle. W and H are width and height of
27120 the exposed area. All are pixel values. W or H zero means redraw
27121 the entire frame. */
27124 expose_frame (struct frame
*f
, int x
, int y
, int w
, int h
)
27127 int mouse_face_overwritten_p
= 0;
27129 TRACE ((stderr
, "expose_frame "));
27131 /* No need to redraw if frame will be redrawn soon. */
27132 if (FRAME_GARBAGED_P (f
))
27134 TRACE ((stderr
, " garbaged\n"));
27138 /* If basic faces haven't been realized yet, there is no point in
27139 trying to redraw anything. This can happen when we get an expose
27140 event while Emacs is starting, e.g. by moving another window. */
27141 if (FRAME_FACE_CACHE (f
) == NULL
27142 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
27144 TRACE ((stderr
, " no faces\n"));
27148 if (w
== 0 || h
== 0)
27151 r
.width
= FRAME_COLUMN_WIDTH (f
) * FRAME_COLS (f
);
27152 r
.height
= FRAME_LINE_HEIGHT (f
) * FRAME_LINES (f
);
27162 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.x
, r
.y
, r
.width
, r
.height
));
27163 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
27165 if (WINDOWP (f
->tool_bar_window
))
27166 mouse_face_overwritten_p
27167 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
27169 #ifdef HAVE_X_WINDOWS
27171 #ifndef USE_X_TOOLKIT
27172 if (WINDOWP (f
->menu_bar_window
))
27173 mouse_face_overwritten_p
27174 |= expose_window (XWINDOW (f
->menu_bar_window
), &r
);
27175 #endif /* not USE_X_TOOLKIT */
27179 /* Some window managers support a focus-follows-mouse style with
27180 delayed raising of frames. Imagine a partially obscured frame,
27181 and moving the mouse into partially obscured mouse-face on that
27182 frame. The visible part of the mouse-face will be highlighted,
27183 then the WM raises the obscured frame. With at least one WM, KDE
27184 2.1, Emacs is not getting any event for the raising of the frame
27185 (even tried with SubstructureRedirectMask), only Expose events.
27186 These expose events will draw text normally, i.e. not
27187 highlighted. Which means we must redo the highlight here.
27188 Subsume it under ``we love X''. --gerd 2001-08-15 */
27189 /* Included in Windows version because Windows most likely does not
27190 do the right thing if any third party tool offers
27191 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
27192 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
27194 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
27195 if (f
== hlinfo
->mouse_face_mouse_frame
)
27197 int mouse_x
= hlinfo
->mouse_face_mouse_x
;
27198 int mouse_y
= hlinfo
->mouse_face_mouse_y
;
27199 clear_mouse_face (hlinfo
);
27200 note_mouse_highlight (f
, mouse_x
, mouse_y
);
27207 Determine the intersection of two rectangles R1 and R2. Return
27208 the intersection in *RESULT. Value is non-zero if RESULT is not
27212 x_intersect_rectangles (XRectangle
*r1
, XRectangle
*r2
, XRectangle
*result
)
27214 XRectangle
*left
, *right
;
27215 XRectangle
*upper
, *lower
;
27216 int intersection_p
= 0;
27218 /* Rearrange so that R1 is the left-most rectangle. */
27220 left
= r1
, right
= r2
;
27222 left
= r2
, right
= r1
;
27224 /* X0 of the intersection is right.x0, if this is inside R1,
27225 otherwise there is no intersection. */
27226 if (right
->x
<= left
->x
+ left
->width
)
27228 result
->x
= right
->x
;
27230 /* The right end of the intersection is the minimum of the
27231 the right ends of left and right. */
27232 result
->width
= (min (left
->x
+ left
->width
, right
->x
+ right
->width
)
27235 /* Same game for Y. */
27237 upper
= r1
, lower
= r2
;
27239 upper
= r2
, lower
= r1
;
27241 /* The upper end of the intersection is lower.y0, if this is inside
27242 of upper. Otherwise, there is no intersection. */
27243 if (lower
->y
<= upper
->y
+ upper
->height
)
27245 result
->y
= lower
->y
;
27247 /* The lower end of the intersection is the minimum of the lower
27248 ends of upper and lower. */
27249 result
->height
= (min (lower
->y
+ lower
->height
,
27250 upper
->y
+ upper
->height
)
27252 intersection_p
= 1;
27256 return intersection_p
;
27259 #endif /* HAVE_WINDOW_SYSTEM */
27262 /***********************************************************************
27264 ***********************************************************************/
27267 syms_of_xdisp (void)
27269 Vwith_echo_area_save_vector
= Qnil
;
27270 staticpro (&Vwith_echo_area_save_vector
);
27272 Vmessage_stack
= Qnil
;
27273 staticpro (&Vmessage_stack
);
27275 Qinhibit_redisplay
= intern_c_string ("inhibit-redisplay");
27276 staticpro (&Qinhibit_redisplay
);
27278 message_dolog_marker1
= Fmake_marker ();
27279 staticpro (&message_dolog_marker1
);
27280 message_dolog_marker2
= Fmake_marker ();
27281 staticpro (&message_dolog_marker2
);
27282 message_dolog_marker3
= Fmake_marker ();
27283 staticpro (&message_dolog_marker3
);
27286 defsubr (&Sdump_frame_glyph_matrix
);
27287 defsubr (&Sdump_glyph_matrix
);
27288 defsubr (&Sdump_glyph_row
);
27289 defsubr (&Sdump_tool_bar_row
);
27290 defsubr (&Strace_redisplay
);
27291 defsubr (&Strace_to_stderr
);
27293 #ifdef HAVE_WINDOW_SYSTEM
27294 defsubr (&Stool_bar_lines_needed
);
27295 defsubr (&Slookup_image_map
);
27297 defsubr (&Sformat_mode_line
);
27298 defsubr (&Sinvisible_p
);
27299 defsubr (&Scurrent_bidi_paragraph_direction
);
27301 staticpro (&Qmenu_bar_update_hook
);
27302 Qmenu_bar_update_hook
= intern_c_string ("menu-bar-update-hook");
27304 staticpro (&Qoverriding_terminal_local_map
);
27305 Qoverriding_terminal_local_map
= intern_c_string ("overriding-terminal-local-map");
27307 staticpro (&Qoverriding_local_map
);
27308 Qoverriding_local_map
= intern_c_string ("overriding-local-map");
27310 staticpro (&Qwindow_scroll_functions
);
27311 Qwindow_scroll_functions
= intern_c_string ("window-scroll-functions");
27313 staticpro (&Qwindow_text_change_functions
);
27314 Qwindow_text_change_functions
= intern_c_string ("window-text-change-functions");
27316 staticpro (&Qredisplay_end_trigger_functions
);
27317 Qredisplay_end_trigger_functions
= intern_c_string ("redisplay-end-trigger-functions");
27319 staticpro (&Qinhibit_point_motion_hooks
);
27320 Qinhibit_point_motion_hooks
= intern_c_string ("inhibit-point-motion-hooks");
27322 Qeval
= intern_c_string ("eval");
27323 staticpro (&Qeval
);
27325 QCdata
= intern_c_string (":data");
27326 staticpro (&QCdata
);
27327 Qdisplay
= intern_c_string ("display");
27328 staticpro (&Qdisplay
);
27329 Qspace_width
= intern_c_string ("space-width");
27330 staticpro (&Qspace_width
);
27331 Qraise
= intern_c_string ("raise");
27332 staticpro (&Qraise
);
27333 Qslice
= intern_c_string ("slice");
27334 staticpro (&Qslice
);
27335 Qspace
= intern_c_string ("space");
27336 staticpro (&Qspace
);
27337 Qmargin
= intern_c_string ("margin");
27338 staticpro (&Qmargin
);
27339 Qpointer
= intern_c_string ("pointer");
27340 staticpro (&Qpointer
);
27341 Qleft_margin
= intern_c_string ("left-margin");
27342 staticpro (&Qleft_margin
);
27343 Qright_margin
= intern_c_string ("right-margin");
27344 staticpro (&Qright_margin
);
27345 Qcenter
= intern_c_string ("center");
27346 staticpro (&Qcenter
);
27347 Qline_height
= intern_c_string ("line-height");
27348 staticpro (&Qline_height
);
27349 QCalign_to
= intern_c_string (":align-to");
27350 staticpro (&QCalign_to
);
27351 QCrelative_width
= intern_c_string (":relative-width");
27352 staticpro (&QCrelative_width
);
27353 QCrelative_height
= intern_c_string (":relative-height");
27354 staticpro (&QCrelative_height
);
27355 QCeval
= intern_c_string (":eval");
27356 staticpro (&QCeval
);
27357 QCpropertize
= intern_c_string (":propertize");
27358 staticpro (&QCpropertize
);
27359 QCfile
= intern_c_string (":file");
27360 staticpro (&QCfile
);
27361 Qfontified
= intern_c_string ("fontified");
27362 staticpro (&Qfontified
);
27363 Qfontification_functions
= intern_c_string ("fontification-functions");
27364 staticpro (&Qfontification_functions
);
27365 Qtrailing_whitespace
= intern_c_string ("trailing-whitespace");
27366 staticpro (&Qtrailing_whitespace
);
27367 Qescape_glyph
= intern_c_string ("escape-glyph");
27368 staticpro (&Qescape_glyph
);
27369 Qnobreak_space
= intern_c_string ("nobreak-space");
27370 staticpro (&Qnobreak_space
);
27371 Qimage
= intern_c_string ("image");
27372 staticpro (&Qimage
);
27373 Qtext
= intern_c_string ("text");
27374 staticpro (&Qtext
);
27375 Qboth
= intern_c_string ("both");
27376 staticpro (&Qboth
);
27377 Qboth_horiz
= intern_c_string ("both-horiz");
27378 staticpro (&Qboth_horiz
);
27379 Qtext_image_horiz
= intern_c_string ("text-image-horiz");
27380 staticpro (&Qtext_image_horiz
);
27381 QCmap
= intern_c_string (":map");
27382 staticpro (&QCmap
);
27383 QCpointer
= intern_c_string (":pointer");
27384 staticpro (&QCpointer
);
27385 Qrect
= intern_c_string ("rect");
27386 staticpro (&Qrect
);
27387 Qcircle
= intern_c_string ("circle");
27388 staticpro (&Qcircle
);
27389 Qpoly
= intern_c_string ("poly");
27390 staticpro (&Qpoly
);
27391 Qmessage_truncate_lines
= intern_c_string ("message-truncate-lines");
27392 staticpro (&Qmessage_truncate_lines
);
27393 Qgrow_only
= intern_c_string ("grow-only");
27394 staticpro (&Qgrow_only
);
27395 Qinhibit_menubar_update
= intern_c_string ("inhibit-menubar-update");
27396 staticpro (&Qinhibit_menubar_update
);
27397 Qinhibit_eval_during_redisplay
= intern_c_string ("inhibit-eval-during-redisplay");
27398 staticpro (&Qinhibit_eval_during_redisplay
);
27399 Qposition
= intern_c_string ("position");
27400 staticpro (&Qposition
);
27401 Qbuffer_position
= intern_c_string ("buffer-position");
27402 staticpro (&Qbuffer_position
);
27403 Qobject
= intern_c_string ("object");
27404 staticpro (&Qobject
);
27405 Qbar
= intern_c_string ("bar");
27407 Qhbar
= intern_c_string ("hbar");
27408 staticpro (&Qhbar
);
27409 Qbox
= intern_c_string ("box");
27411 Qhollow
= intern_c_string ("hollow");
27412 staticpro (&Qhollow
);
27413 Qhand
= intern_c_string ("hand");
27414 staticpro (&Qhand
);
27415 Qarrow
= intern_c_string ("arrow");
27416 staticpro (&Qarrow
);
27417 Qtext
= intern_c_string ("text");
27418 staticpro (&Qtext
);
27419 Qinhibit_free_realized_faces
= intern_c_string ("inhibit-free-realized-faces");
27420 staticpro (&Qinhibit_free_realized_faces
);
27422 list_of_error
= Fcons (Fcons (intern_c_string ("error"),
27423 Fcons (intern_c_string ("void-variable"), Qnil
)),
27425 staticpro (&list_of_error
);
27427 Qlast_arrow_position
= intern_c_string ("last-arrow-position");
27428 staticpro (&Qlast_arrow_position
);
27429 Qlast_arrow_string
= intern_c_string ("last-arrow-string");
27430 staticpro (&Qlast_arrow_string
);
27432 Qoverlay_arrow_string
= intern_c_string ("overlay-arrow-string");
27433 staticpro (&Qoverlay_arrow_string
);
27434 Qoverlay_arrow_bitmap
= intern_c_string ("overlay-arrow-bitmap");
27435 staticpro (&Qoverlay_arrow_bitmap
);
27437 echo_buffer
[0] = echo_buffer
[1] = Qnil
;
27438 staticpro (&echo_buffer
[0]);
27439 staticpro (&echo_buffer
[1]);
27441 echo_area_buffer
[0] = echo_area_buffer
[1] = Qnil
;
27442 staticpro (&echo_area_buffer
[0]);
27443 staticpro (&echo_area_buffer
[1]);
27445 Vmessages_buffer_name
= make_pure_c_string ("*Messages*");
27446 staticpro (&Vmessages_buffer_name
);
27448 mode_line_proptrans_alist
= Qnil
;
27449 staticpro (&mode_line_proptrans_alist
);
27450 mode_line_string_list
= Qnil
;
27451 staticpro (&mode_line_string_list
);
27452 mode_line_string_face
= Qnil
;
27453 staticpro (&mode_line_string_face
);
27454 mode_line_string_face_prop
= Qnil
;
27455 staticpro (&mode_line_string_face_prop
);
27456 Vmode_line_unwind_vector
= Qnil
;
27457 staticpro (&Vmode_line_unwind_vector
);
27459 help_echo_string
= Qnil
;
27460 staticpro (&help_echo_string
);
27461 help_echo_object
= Qnil
;
27462 staticpro (&help_echo_object
);
27463 help_echo_window
= Qnil
;
27464 staticpro (&help_echo_window
);
27465 previous_help_echo_string
= Qnil
;
27466 staticpro (&previous_help_echo_string
);
27467 help_echo_pos
= -1;
27469 Qright_to_left
= intern_c_string ("right-to-left");
27470 staticpro (&Qright_to_left
);
27471 Qleft_to_right
= intern_c_string ("left-to-right");
27472 staticpro (&Qleft_to_right
);
27474 #ifdef HAVE_WINDOW_SYSTEM
27475 DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p
,
27476 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
27477 For example, if a block cursor is over a tab, it will be drawn as
27478 wide as that tab on the display. */);
27479 x_stretch_cursor_p
= 0;
27482 DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace
,
27483 doc
: /* *Non-nil means highlight trailing whitespace.
27484 The face used for trailing whitespace is `trailing-whitespace'. */);
27485 Vshow_trailing_whitespace
= Qnil
;
27487 DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display
,
27488 doc
: /* *Control highlighting of nobreak space and soft hyphen.
27489 A value of t means highlight the character itself (for nobreak space,
27490 use face `nobreak-space').
27491 A value of nil means no highlighting.
27492 Other values mean display the escape glyph followed by an ordinary
27493 space or ordinary hyphen. */);
27494 Vnobreak_char_display
= Qt
;
27496 DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer
,
27497 doc
: /* *The pointer shape to show in void text areas.
27498 A value of nil means to show the text pointer. Other options are `arrow',
27499 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'. */);
27500 Vvoid_text_area_pointer
= Qarrow
;
27502 DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay
,
27503 doc
: /* Non-nil means don't actually do any redisplay.
27504 This is used for internal purposes. */);
27505 Vinhibit_redisplay
= Qnil
;
27507 DEFVAR_LISP ("global-mode-string", Vglobal_mode_string
,
27508 doc
: /* String (or mode line construct) included (normally) in `mode-line-format'. */);
27509 Vglobal_mode_string
= Qnil
;
27511 DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position
,
27512 doc
: /* Marker for where to display an arrow on top of the buffer text.
27513 This must be the beginning of a line in order to work.
27514 See also `overlay-arrow-string'. */);
27515 Voverlay_arrow_position
= Qnil
;
27517 DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string
,
27518 doc
: /* String to display as an arrow in non-window frames.
27519 See also `overlay-arrow-position'. */);
27520 Voverlay_arrow_string
= make_pure_c_string ("=>");
27522 DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list
,
27523 doc
: /* List of variables (symbols) which hold markers for overlay arrows.
27524 The symbols on this list are examined during redisplay to determine
27525 where to display overlay arrows. */);
27526 Voverlay_arrow_variable_list
27527 = Fcons (intern_c_string ("overlay-arrow-position"), Qnil
);
27529 DEFVAR_INT ("scroll-step", emacs_scroll_step
,
27530 doc
: /* *The number of lines to try scrolling a window by when point moves out.
27531 If that fails to bring point back on frame, point is centered instead.
27532 If this is zero, point is always centered after it moves off frame.
27533 If you want scrolling to always be a line at a time, you should set
27534 `scroll-conservatively' to a large value rather than set this to 1. */);
27536 DEFVAR_INT ("scroll-conservatively", scroll_conservatively
,
27537 doc
: /* *Scroll up to this many lines, to bring point back on screen.
27538 If point moves off-screen, redisplay will scroll by up to
27539 `scroll-conservatively' lines in order to bring point just barely
27540 onto the screen again. If that cannot be done, then redisplay
27541 recenters point as usual.
27543 If the value is greater than 100, redisplay will never recenter point,
27544 but will always scroll just enough text to bring point into view, even
27545 if you move far away.
27547 A value of zero means always recenter point if it moves off screen. */);
27548 scroll_conservatively
= 0;
27550 DEFVAR_INT ("scroll-margin", scroll_margin
,
27551 doc
: /* *Number of lines of margin at the top and bottom of a window.
27552 Recenter the window whenever point gets within this many lines
27553 of the top or bottom of the window. */);
27556 DEFVAR_LISP ("display-pixels-per-inch", Vdisplay_pixels_per_inch
,
27557 doc
: /* Pixels per inch value for non-window system displays.
27558 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI). */);
27559 Vdisplay_pixels_per_inch
= make_float (72.0);
27562 DEFVAR_INT ("debug-end-pos", debug_end_pos
, doc
: /* Don't ask. */);
27565 DEFVAR_LISP ("truncate-partial-width-windows",
27566 Vtruncate_partial_width_windows
,
27567 doc
: /* Non-nil means truncate lines in windows narrower than the frame.
27568 For an integer value, truncate lines in each window narrower than the
27569 full frame width, provided the window width is less than that integer;
27570 otherwise, respect the value of `truncate-lines'.
27572 For any other non-nil value, truncate lines in all windows that do
27573 not span the full frame width.
27575 A value of nil means to respect the value of `truncate-lines'.
27577 If `word-wrap' is enabled, you might want to reduce this. */);
27578 Vtruncate_partial_width_windows
= make_number (50);
27580 DEFVAR_BOOL ("mode-line-inverse-video", mode_line_inverse_video
,
27581 doc
: /* When nil, display the mode-line/header-line/menu-bar in the default face.
27582 Any other value means to use the appropriate face, `mode-line',
27583 `header-line', or `menu' respectively. */);
27584 mode_line_inverse_video
= 1;
27586 DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit
,
27587 doc
: /* *Maximum buffer size for which line number should be displayed.
27588 If the buffer is bigger than this, the line number does not appear
27589 in the mode line. A value of nil means no limit. */);
27590 Vline_number_display_limit
= Qnil
;
27592 DEFVAR_INT ("line-number-display-limit-width",
27593 line_number_display_limit_width
,
27594 doc
: /* *Maximum line width (in characters) for line number display.
27595 If the average length of the lines near point is bigger than this, then the
27596 line number may be omitted from the mode line. */);
27597 line_number_display_limit_width
= 200;
27599 DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows
,
27600 doc
: /* *Non-nil means highlight region even in nonselected windows. */);
27601 highlight_nonselected_windows
= 0;
27603 DEFVAR_BOOL ("multiple-frames", multiple_frames
,
27604 doc
: /* Non-nil if more than one frame is visible on this display.
27605 Minibuffer-only frames don't count, but iconified frames do.
27606 This variable is not guaranteed to be accurate except while processing
27607 `frame-title-format' and `icon-title-format'. */);
27609 DEFVAR_LISP ("frame-title-format", Vframe_title_format
,
27610 doc
: /* Template for displaying the title bar of visible frames.
27611 \(Assuming the window manager supports this feature.)
27613 This variable has the same structure as `mode-line-format', except that
27614 the %c and %l constructs are ignored. It is used only on frames for
27615 which no explicit name has been set \(see `modify-frame-parameters'). */);
27617 DEFVAR_LISP ("icon-title-format", Vicon_title_format
,
27618 doc
: /* Template for displaying the title bar of an iconified frame.
27619 \(Assuming the window manager supports this feature.)
27620 This variable has the same structure as `mode-line-format' (which see),
27621 and is used only on frames for which no explicit name has been set
27622 \(see `modify-frame-parameters'). */);
27624 = Vframe_title_format
27625 = pure_cons (intern_c_string ("multiple-frames"),
27626 pure_cons (make_pure_c_string ("%b"),
27627 pure_cons (pure_cons (empty_unibyte_string
,
27628 pure_cons (intern_c_string ("invocation-name"),
27629 pure_cons (make_pure_c_string ("@"),
27630 pure_cons (intern_c_string ("system-name"),
27634 DEFVAR_LISP ("message-log-max", Vmessage_log_max
,
27635 doc
: /* Maximum number of lines to keep in the message log buffer.
27636 If nil, disable message logging. If t, log messages but don't truncate
27637 the buffer when it becomes large. */);
27638 Vmessage_log_max
= make_number (100);
27640 DEFVAR_LISP ("window-size-change-functions", Vwindow_size_change_functions
,
27641 doc
: /* Functions called before redisplay, if window sizes have changed.
27642 The value should be a list of functions that take one argument.
27643 Just before redisplay, for each frame, if any of its windows have changed
27644 size since the last redisplay, or have been split or deleted,
27645 all the functions in the list are called, with the frame as argument. */);
27646 Vwindow_size_change_functions
= Qnil
;
27648 DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions
,
27649 doc
: /* List of functions to call before redisplaying a window with scrolling.
27650 Each function is called with two arguments, the window and its new
27651 display-start position. Note that these functions are also called by
27652 `set-window-buffer'. Also note that the value of `window-end' is not
27653 valid when these functions are called. */);
27654 Vwindow_scroll_functions
= Qnil
;
27656 DEFVAR_LISP ("window-text-change-functions",
27657 Vwindow_text_change_functions
,
27658 doc
: /* Functions to call in redisplay when text in the window might change. */);
27659 Vwindow_text_change_functions
= Qnil
;
27661 DEFVAR_LISP ("redisplay-end-trigger-functions", Vredisplay_end_trigger_functions
,
27662 doc
: /* Functions called when redisplay of a window reaches the end trigger.
27663 Each function is called with two arguments, the window and the end trigger value.
27664 See `set-window-redisplay-end-trigger'. */);
27665 Vredisplay_end_trigger_functions
= Qnil
;
27667 DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window
,
27668 doc
: /* *Non-nil means autoselect window with mouse pointer.
27669 If nil, do not autoselect windows.
27670 A positive number means delay autoselection by that many seconds: a
27671 window is autoselected only after the mouse has remained in that
27672 window for the duration of the delay.
27673 A negative number has a similar effect, but causes windows to be
27674 autoselected only after the mouse has stopped moving. \(Because of
27675 the way Emacs compares mouse events, you will occasionally wait twice
27676 that time before the window gets selected.\)
27677 Any other value means to autoselect window instantaneously when the
27678 mouse pointer enters it.
27680 Autoselection selects the minibuffer only if it is active, and never
27681 unselects the minibuffer if it is active.
27683 When customizing this variable make sure that the actual value of
27684 `focus-follows-mouse' matches the behavior of your window manager. */);
27685 Vmouse_autoselect_window
= Qnil
;
27687 DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars
,
27688 doc
: /* *Non-nil means automatically resize tool-bars.
27689 This dynamically changes the tool-bar's height to the minimum height
27690 that is needed to make all tool-bar items visible.
27691 If value is `grow-only', the tool-bar's height is only increased
27692 automatically; to decrease the tool-bar height, use \\[recenter]. */);
27693 Vauto_resize_tool_bars
= Qt
;
27695 DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p
,
27696 doc
: /* *Non-nil means raise tool-bar buttons when the mouse moves over them. */);
27697 auto_raise_tool_bar_buttons_p
= 1;
27699 DEFVAR_BOOL ("make-cursor-line-fully-visible", make_cursor_line_fully_visible_p
,
27700 doc
: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible. */);
27701 make_cursor_line_fully_visible_p
= 1;
27703 DEFVAR_LISP ("tool-bar-border", Vtool_bar_border
,
27704 doc
: /* *Border below tool-bar in pixels.
27705 If an integer, use it as the height of the border.
27706 If it is one of `internal-border-width' or `border-width', use the
27707 value of the corresponding frame parameter.
27708 Otherwise, no border is added below the tool-bar. */);
27709 Vtool_bar_border
= Qinternal_border_width
;
27711 DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin
,
27712 doc
: /* *Margin around tool-bar buttons in pixels.
27713 If an integer, use that for both horizontal and vertical margins.
27714 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
27715 HORZ specifying the horizontal margin, and VERT specifying the
27716 vertical margin. */);
27717 Vtool_bar_button_margin
= make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
27719 DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief
,
27720 doc
: /* *Relief thickness of tool-bar buttons. */);
27721 tool_bar_button_relief
= DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
27723 DEFVAR_LISP ("tool-bar-style", Vtool_bar_style
,
27724 doc
: /* Tool bar style to use.
27726 image - show images only
27727 text - show text only
27728 both - show both, text below image
27729 both-horiz - show text to the right of the image
27730 text-image-horiz - show text to the left of the image
27731 any other - use system default or image if no system default. */);
27732 Vtool_bar_style
= Qnil
;
27734 DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size
,
27735 doc
: /* *Maximum number of characters a label can have to be shown.
27736 The tool bar style must also show labels for this to have any effect, see
27737 `tool-bar-style'. */);
27738 tool_bar_max_label_size
= DEFAULT_TOOL_BAR_LABEL_SIZE
;
27740 DEFVAR_LISP ("fontification-functions", Vfontification_functions
,
27741 doc
: /* List of functions to call to fontify regions of text.
27742 Each function is called with one argument POS. Functions must
27743 fontify a region starting at POS in the current buffer, and give
27744 fontified regions the property `fontified'. */);
27745 Vfontification_functions
= Qnil
;
27746 Fmake_variable_buffer_local (Qfontification_functions
);
27748 DEFVAR_BOOL ("unibyte-display-via-language-environment",
27749 unibyte_display_via_language_environment
,
27750 doc
: /* *Non-nil means display unibyte text according to language environment.
27751 Specifically, this means that raw bytes in the range 160-255 decimal
27752 are displayed by converting them to the equivalent multibyte characters
27753 according to the current language environment. As a result, they are
27754 displayed according to the current fontset.
27756 Note that this variable affects only how these bytes are displayed,
27757 but does not change the fact they are interpreted as raw bytes. */);
27758 unibyte_display_via_language_environment
= 0;
27760 DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height
,
27761 doc
: /* *Maximum height for resizing mini-windows.
27762 If a float, it specifies a fraction of the mini-window frame's height.
27763 If an integer, it specifies a number of lines. */);
27764 Vmax_mini_window_height
= make_float (0.25);
27766 DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows
,
27767 doc
: /* *How to resize mini-windows.
27768 A value of nil means don't automatically resize mini-windows.
27769 A value of t means resize them to fit the text displayed in them.
27770 A value of `grow-only', the default, means let mini-windows grow
27771 only, until their display becomes empty, at which point the windows
27772 go back to their normal size. */);
27773 Vresize_mini_windows
= Qgrow_only
;
27775 DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist
,
27776 doc
: /* Alist specifying how to blink the cursor off.
27777 Each element has the form (ON-STATE . OFF-STATE). Whenever the
27778 `cursor-type' frame-parameter or variable equals ON-STATE,
27779 comparing using `equal', Emacs uses OFF-STATE to specify
27780 how to blink it off. ON-STATE and OFF-STATE are values for
27781 the `cursor-type' frame parameter.
27783 If a frame's ON-STATE has no entry in this list,
27784 the frame's other specifications determine how to blink the cursor off. */);
27785 Vblink_cursor_alist
= Qnil
;
27787 DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p
,
27788 doc
: /* Allow or disallow automatic horizontal scrolling of windows.
27789 If non-nil, windows are automatically scrolled horizontally to make
27790 point visible. */);
27791 automatic_hscrolling_p
= 1;
27792 Qauto_hscroll_mode
= intern_c_string ("auto-hscroll-mode");
27793 staticpro (&Qauto_hscroll_mode
);
27795 DEFVAR_INT ("hscroll-margin", hscroll_margin
,
27796 doc
: /* *How many columns away from the window edge point is allowed to get
27797 before automatic hscrolling will horizontally scroll the window. */);
27798 hscroll_margin
= 5;
27800 DEFVAR_LISP ("hscroll-step", Vhscroll_step
,
27801 doc
: /* *How many columns to scroll the window when point gets too close to the edge.
27802 When point is less than `hscroll-margin' columns from the window
27803 edge, automatic hscrolling will scroll the window by the amount of columns
27804 determined by this variable. If its value is a positive integer, scroll that
27805 many columns. If it's a positive floating-point number, it specifies the
27806 fraction of the window's width to scroll. If it's nil or zero, point will be
27807 centered horizontally after the scroll. Any other value, including negative
27808 numbers, are treated as if the value were zero.
27810 Automatic hscrolling always moves point outside the scroll margin, so if
27811 point was more than scroll step columns inside the margin, the window will
27812 scroll more than the value given by the scroll step.
27814 Note that the lower bound for automatic hscrolling specified by `scroll-left'
27815 and `scroll-right' overrides this variable's effect. */);
27816 Vhscroll_step
= make_number (0);
27818 DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines
,
27819 doc
: /* If non-nil, messages are truncated instead of resizing the echo area.
27820 Bind this around calls to `message' to let it take effect. */);
27821 message_truncate_lines
= 0;
27823 DEFVAR_LISP ("menu-bar-update-hook", Vmenu_bar_update_hook
,
27824 doc
: /* Normal hook run to update the menu bar definitions.
27825 Redisplay runs this hook before it redisplays the menu bar.
27826 This is used to update submenus such as Buffers,
27827 whose contents depend on various data. */);
27828 Vmenu_bar_update_hook
= Qnil
;
27830 DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame
,
27831 doc
: /* Frame for which we are updating a menu.
27832 The enable predicate for a menu binding should check this variable. */);
27833 Vmenu_updating_frame
= Qnil
;
27835 DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update
,
27836 doc
: /* Non-nil means don't update menu bars. Internal use only. */);
27837 inhibit_menubar_update
= 0;
27839 DEFVAR_LISP ("wrap-prefix", Vwrap_prefix
,
27840 doc
: /* Prefix prepended to all continuation lines at display time.
27841 The value may be a string, an image, or a stretch-glyph; it is
27842 interpreted in the same way as the value of a `display' text property.
27844 This variable is overridden by any `wrap-prefix' text or overlay
27847 To add a prefix to non-continuation lines, use `line-prefix'. */);
27848 Vwrap_prefix
= Qnil
;
27849 staticpro (&Qwrap_prefix
);
27850 Qwrap_prefix
= intern_c_string ("wrap-prefix");
27851 Fmake_variable_buffer_local (Qwrap_prefix
);
27853 DEFVAR_LISP ("line-prefix", Vline_prefix
,
27854 doc
: /* Prefix prepended to all non-continuation lines at display time.
27855 The value may be a string, an image, or a stretch-glyph; it is
27856 interpreted in the same way as the value of a `display' text property.
27858 This variable is overridden by any `line-prefix' text or overlay
27861 To add a prefix to continuation lines, use `wrap-prefix'. */);
27862 Vline_prefix
= Qnil
;
27863 staticpro (&Qline_prefix
);
27864 Qline_prefix
= intern_c_string ("line-prefix");
27865 Fmake_variable_buffer_local (Qline_prefix
);
27867 DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay
,
27868 doc
: /* Non-nil means don't eval Lisp during redisplay. */);
27869 inhibit_eval_during_redisplay
= 0;
27871 DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces
,
27872 doc
: /* Non-nil means don't free realized faces. Internal use only. */);
27873 inhibit_free_realized_faces
= 0;
27876 DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id
,
27877 doc
: /* Inhibit try_window_id display optimization. */);
27878 inhibit_try_window_id
= 0;
27880 DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing
,
27881 doc
: /* Inhibit try_window_reusing display optimization. */);
27882 inhibit_try_window_reusing
= 0;
27884 DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement
,
27885 doc
: /* Inhibit try_cursor_movement display optimization. */);
27886 inhibit_try_cursor_movement
= 0;
27887 #endif /* GLYPH_DEBUG */
27889 DEFVAR_INT ("overline-margin", overline_margin
,
27890 doc
: /* *Space between overline and text, in pixels.
27891 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
27892 margin to the caracter height. */);
27893 overline_margin
= 2;
27895 DEFVAR_INT ("underline-minimum-offset",
27896 underline_minimum_offset
,
27897 doc
: /* Minimum distance between baseline and underline.
27898 This can improve legibility of underlined text at small font sizes,
27899 particularly when using variable `x-use-underline-position-properties'
27900 with fonts that specify an UNDERLINE_POSITION relatively close to the
27901 baseline. The default value is 1. */);
27902 underline_minimum_offset
= 1;
27904 DEFVAR_BOOL ("display-hourglass", display_hourglass_p
,
27905 doc
: /* Non-nil means show an hourglass pointer, when Emacs is busy.
27906 This feature only works when on a window system that can change
27907 cursor shapes. */);
27908 display_hourglass_p
= 1;
27910 DEFVAR_LISP ("hourglass-delay", Vhourglass_delay
,
27911 doc
: /* *Seconds to wait before displaying an hourglass pointer when Emacs is busy. */);
27912 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
27914 hourglass_atimer
= NULL
;
27915 hourglass_shown_p
= 0;
27917 DEFSYM (Qglyphless_char
, "glyphless-char");
27918 DEFSYM (Qhex_code
, "hex-code");
27919 DEFSYM (Qempty_box
, "empty-box");
27920 DEFSYM (Qthin_space
, "thin-space");
27921 DEFSYM (Qzero_width
, "zero-width");
27923 DEFSYM (Qglyphless_char_display
, "glyphless-char-display");
27924 /* Intern this now in case it isn't already done.
27925 Setting this variable twice is harmless.
27926 But don't staticpro it here--that is done in alloc.c. */
27927 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
27928 Fput (Qglyphless_char_display
, Qchar_table_extra_slots
, make_number (1));
27930 DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display
,
27931 doc
: /* Char-table defining glyphless characters.
27932 Each element, if non-nil, should be one of the following:
27933 an ASCII acronym string: display this string in a box
27934 `hex-code': display the hexadecimal code of a character in a box
27935 `empty-box': display as an empty box
27936 `thin-space': display as 1-pixel width space
27937 `zero-width': don't display
27938 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
27939 display method for graphical terminals and text terminals respectively.
27940 GRAPHICAL and TEXT should each have one of the values listed above.
27942 The char-table has one extra slot to control the display of a character for
27943 which no font is found. This slot only takes effect on graphical terminals.
27944 Its value should be an ASCII acronym string, `hex-code', `empty-box', or
27945 `thin-space'. The default is `empty-box'. */);
27946 Vglyphless_char_display
= Fmake_char_table (Qglyphless_char_display
, Qnil
);
27947 Fset_char_table_extra_slot (Vglyphless_char_display
, make_number (0),
27952 /* Initialize this module when Emacs starts. */
27957 Lisp_Object root_window
;
27958 struct window
*mini_w
;
27960 current_header_line_height
= current_mode_line_height
= -1;
27962 CHARPOS (this_line_start_pos
) = 0;
27964 mini_w
= XWINDOW (minibuf_window
);
27965 root_window
= FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w
)));
27966 echo_area_window
= minibuf_window
;
27968 if (!noninteractive
)
27970 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (root_window
)));
27973 XWINDOW (root_window
)->top_line
= make_number (FRAME_TOP_MARGIN (f
));
27974 set_window_height (root_window
,
27975 FRAME_LINES (f
) - 1 - FRAME_TOP_MARGIN (f
),
27977 mini_w
->top_line
= make_number (FRAME_LINES (f
) - 1);
27978 set_window_height (minibuf_window
, 1, 0);
27980 XWINDOW (root_window
)->total_cols
= make_number (FRAME_COLS (f
));
27981 mini_w
->total_cols
= make_number (FRAME_COLS (f
));
27983 scratch_glyph_row
.glyphs
[TEXT_AREA
] = scratch_glyphs
;
27984 scratch_glyph_row
.glyphs
[TEXT_AREA
+ 1]
27985 = scratch_glyphs
+ MAX_SCRATCH_GLYPHS
;
27987 /* The default ellipsis glyphs `...'. */
27988 for (i
= 0; i
< 3; ++i
)
27989 default_invis_vector
[i
] = make_number ('.');
27993 /* Allocate the buffer for frame titles.
27994 Also used for `format-mode-line'. */
27996 mode_line_noprop_buf
= (char *) xmalloc (size
);
27997 mode_line_noprop_buf_end
= mode_line_noprop_buf
+ size
;
27998 mode_line_noprop_ptr
= mode_line_noprop_buf
;
27999 mode_line_target
= MODE_LINE_DISPLAY
;
28002 help_echo_showing_p
= 0;
28005 /* Since w32 does not support atimers, it defines its own implementation of
28006 the following three functions in w32fns.c. */
28009 /* Platform-independent portion of hourglass implementation. */
28011 /* Return non-zero if houglass timer has been started or hourglass is shown. */
28013 hourglass_started (void)
28015 return hourglass_shown_p
|| hourglass_atimer
!= NULL
;
28018 /* Cancel a currently active hourglass timer, and start a new one. */
28020 start_hourglass (void)
28022 #if defined (HAVE_WINDOW_SYSTEM)
28024 int secs
, usecs
= 0;
28026 cancel_hourglass ();
28028 if (INTEGERP (Vhourglass_delay
)
28029 && XINT (Vhourglass_delay
) > 0)
28030 secs
= XFASTINT (Vhourglass_delay
);
28031 else if (FLOATP (Vhourglass_delay
)
28032 && XFLOAT_DATA (Vhourglass_delay
) > 0)
28035 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
28036 secs
= XFASTINT (tem
);
28037 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
28040 secs
= DEFAULT_HOURGLASS_DELAY
;
28042 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
28043 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
28044 show_hourglass
, NULL
);
28049 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
28052 cancel_hourglass (void)
28054 #if defined (HAVE_WINDOW_SYSTEM)
28055 if (hourglass_atimer
)
28057 cancel_atimer (hourglass_atimer
);
28058 hourglass_atimer
= NULL
;
28061 if (hourglass_shown_p
)
28065 #endif /* ! WINDOWSNT */